@voybio/ace-swarm 2.4.2 → 2.4.4

package/dist/runtime-executor.js

@@ -20,7 +20,7 @@ import { getWorkspaceStorePath, storeExistsSync, } from "./store/store-snapshot.
 import { operationalArtifactVirtualPath } from "./store/store-artifacts.js";
 import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 import { LocalModelRuntimeRepository, withLocalModelRuntimeRepository, } from "./store/repositories/local-model-runtime-repository.js";
-import { proposePlanDeterministic, validatePlan } from "./plan-proposal.js";
+import { loadAcceptanceTraceContract, proposePlanDeterministic, validatePlan } from "./plan-proposal.js";
 export const RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH = "agent-state/runtime-executor-sessions.json";
 export const RUNTIME_EXECUTOR_SESSION_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/RUNTIME_EXECUTOR_SESSION_REGISTRY.schema.json";
 export const RUNTIME_EXECUTOR_SESSION_SCHEMA_NAME = "runtime-executor-session-registry@1.0.0";
@@ -583,6 +583,7 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
             }
             return;
         }
+        let mutationLanePolicy = { mutation_lane: "raw_write_allowed" };
         // ── Plan validation preflight (Task 6) ───────────────────────────────
         {
             const currentValidatedPlanId = registryStart.validated_plan_id;
@@ -592,6 +593,13 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
                     const proposal = proposePlanDeterministic(task);
                     const verdict = await validatePlan({ proposal, sessionId });
                     if (verdict.ok) {
+                        const structuralStep = proposal.steps.find((step) => step.structural_edit_plan_required === true);
+                        if (structuralStep) {
+                            mutationLanePolicy = {
+                                mutation_lane: "structural_edit",
+                                waiver: structuralStep.structural_edit_waiver ?? null,
+                            };
+                        }
                         // Persist validated_plan_id opportunistically. This is a readiness hint,
                         // not a hard gate on unattended execution.
                         await mutateRegistry((registry) => {
@@ -606,6 +614,16 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
                     // even when the planner/model path or trace lookup is unavailable.
                 }
             }
+            else {
+                const contract = loadAcceptanceTraceContract(currentValidatedPlanId);
+                const structuralStep = contract?.steps.find((step) => step.structural_edit_plan_required === true);
+                if (structuralStep) {
+                    mutationLanePolicy = {
+                        mutation_lane: "structural_edit",
+                        waiver: structuralStep.structural_edit_waiver ?? null,
+                    };
+                }
+            }
         }
         // ── End plan validation preflight ────────────────────────────────────
         setSessionPhase(sessionId, "workspace_before_run");
@@ -706,7 +724,7 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
             const turnStartedAt = new Date().toISOString();
             const paths = buildTurnPaths(sessionId, sessionSnapshot.workspace_path, turnNumber);
             // Build capability-filtered tool catalog in-memory from the resolved model class.
-            const filteredCatalog = buildFilteredToolCatalog(effectiveModelClass);
+            const filteredCatalog = buildFilteredToolCatalog(effectiveModelClass, undefined, mutationLanePolicy);
             const capabilitySnapshotId = randomUUID();
             const selectedBudget = resolveEffectiveSurgicalReadBudget(runtimeProfileSnapshot.profile, effectiveModelClass);
             const toolCatalog = filteredCatalog.entries.map((e) => ({
@@ -1078,6 +1096,31 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
             for (const toolCall of response.tool_calls) {
                 const toolStartedAt = new Date().toISOString();
                 noteProgress(`Runtime tool ${toolCall.name} started during turn ${turnNumber}.`);
+                const fencedReason = filteredCatalog.unavailable_tools.find((entry) => entry.name === toolCall.name && entry.reason_code === "structural_lane_fenced");
+                if (fencedReason) {
+                    const toolResult = {
+                        ok: false,
+                        name: toolCall.name,
+                        summary: fencedReason.reason,
+                        request_path: "policy://structural-lane-fenced/request",
+                        response_path: "policy://structural-lane-fenced/response",
+                        error: { reason_code: "structural_lane_fenced", summary: fencedReason.reason },
+                    };
+                    await appendStatusEventSafe({
+                        source_module: "capability-framework",
+                        event_type: "STRUCTURAL_LANE_FENCED",
+                        status: "blocked",
+                        summary: fencedReason.reason,
+                        payload: {
+                            session_id: sessionId,
+                            turn_number: turnNumber,
+                            tool_name: toolCall.name,
+                            reason_code: "structural_lane_fenced",
+                        },
+                    }).catch(() => undefined);
+                    toolCalls.push(mapToolCallResult(toolResult, toolStartedAt));
+                    continue;
+                }
                 const toolResult = await executeRuntimeTool(toolCall.name, toolCall.input, {
                     session_id: sessionId,
                     workspace_path: sessionSnapshot.workspace_path,

package/dist/runtime-tool-specs.d.ts

@@ -102,6 +102,13 @@ export interface FilteredToolCatalog {
     }[];
     tool_cost_class: Record<string, ToolCostClass>;
 }
-export declare function buildFilteredToolCatalog(modelClass: ModelClass | undefined, allowedTools?: string[]): FilteredToolCatalog;
+export interface MutationLanePolicy {
+    mutation_lane: "structural_edit" | "raw_write_allowed";
+    waiver?: {
+        reason: string;
+        evidence_ref: string;
+    } | null;
+}
+export declare function buildFilteredToolCatalog(modelClass: ModelClass | undefined, allowedTools?: string[], lanePolicy?: MutationLanePolicy): FilteredToolCatalog;
 export {};
 //# sourceMappingURL=runtime-tool-specs.d.ts.map

package/dist/runtime-tool-specs.js

@@ -594,7 +594,12 @@ function extractCostClass(tool) {
         return "moderate";
     return "cheap";
 }
-export function buildFilteredToolCatalog(modelClass, allowedTools) {
+const STRUCTURAL_LANE_FENCED = new Set([
+    "write_workspace_file",
+    "safe_edit_file",
+    "apply_patch",
+]);
+export function buildFilteredToolCatalog(modelClass, allowedTools, lanePolicy) {
     const allTools = listRuntimeToolSpecs();
     const effectiveModelClass = modelClass ?? "frontier";
     const allowed = allowedTools ? new Set(allowedTools) : null;
@@ -621,6 +626,19 @@ export function buildFilteredToolCatalog(modelClass, allowedTools) {
             cost_class: costClass,
         });
     }
+    if (lanePolicy?.mutation_lane === "structural_edit"
+        && !(lanePolicy.waiver?.reason?.trim() && lanePolicy.waiver?.evidence_ref?.trim())) {
+        entries = entries.filter((entry) => {
+            if (!STRUCTURAL_LANE_FENCED.has(entry.name))
+                return true;
+            unavailable.push({
+                name: entry.name,
+                reason: "Disabled by structural_edit lane. Use astgrep_locate -> compile_structural_edit -> preview_structural_edit -> astgrep_rewrite, or attach an evidence-backed structural_edit_waiver to the step.",
+                reason_code: "structural_lane_fenced",
+            });
+            return false;
+        });
+    }
     if (effectiveModelClass === "small_local" || effectiveModelClass === "mid") {
         const priority = new Map(SMALL_LOCAL_PRIORITY_TOOL_NAMES.map((name, idx) => [name, idx]));
         entries.sort((a, b) => {

package/dist/schemas.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { extractFencedYamlBlock, parseTealConfigMarkdown } from "./gate-contract.js";
 import { existsSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
 import { isInside, mapAceWorkspaceRelativePath } from "./helpers.js";
@@ -616,26 +617,26 @@ export function validateStatusEventsNdjsonContent(content) {
 }
 export function validateTealConfigContent(content) {
     const errors = [];
-    const fenceCount = (content.match(/```/g) ?? []).length;
-    const fencedBlocks = [...content.matchAll(/```([^\n]*)\n([\s\S]*?)```/g)];
-    if (fenceCount !== 2 || fencedBlocks.length !== 1) {
-        errors.push(`TEAL_CONFIG.md must contain exactly one fenced code block; found ${fencedBlocks.length}`);
+    const block = extractFencedYamlBlock(content);
+    if (!block) {
+        errors.push("TEAL_CONFIG.md must contain exactly one fenced code block; found 0 or multiple blocks");
     }
-    const block = fencedBlocks[0];
     if (block) {
-        const language = block[1].trim().toLowerCase();
-        const yamlBody = block[2].trim();
-        if (language !== "yaml") {
-            errors.push(`TEAL_CONFIG.md active config block must be fenced as \`\`\`yaml, found "${block[1].trim() || "(none)"}"`);
+        if (block.language !== "yaml") {
+            errors.push(`TEAL_CONFIG.md active config block must be fenced as \`\`\`yaml, found "${block.language || "(none)"}"`);
         }
-        if (!yamlBody) {
+        if (!block.yaml) {
             errors.push("TEAL_CONFIG.md YAML block is empty");
         }
-        else {
-            for (const section of ["modules", "pipelines"]) {
-                if (!new RegExp(`^\\s*${section}:`, "m").test(yamlBody)) {
-                    errors.push(`TEAL_CONFIG.md YAML block is missing required top-level section "${section}:"`);
-                }
+        else if (!parseTealConfigMarkdown(content)) {
+            errors.push("TEAL_CONFIG.md YAML block could not be parsed");
+        }
+    }
+    const parsed = parseTealConfigMarkdown(content);
+    if (parsed) {
+        for (const section of ["modules", "pipelines"]) {
+            if (!parsed[section] || typeof parsed[section] !== "object") {
+                errors.push(`TEAL_CONFIG.md YAML block is missing required top-level section "${section}:"`);
             }
         }
     }

package/dist/store/bootstrap-store.js

@@ -22,6 +22,7 @@ import { openStore } from "./ace-packed-store.js";
 import { bakeAllCoreKnowledge } from "./knowledge-bake.js";
 import { bakeTopology } from "./topology-bake.js";
 import { buildCatalog } from "./catalog-builder.js";
+import { migratePackageGateContract, recordPackageGateContractVersion, } from "./gate-contract-migration.js";
 import { HostFileMaterializer } from "./materializers/host-file-materializer.js";
 import { ProjectionManager } from "./materializers/projection-manager.js";
 import { TodoSyncer } from "./materializers/todo-syncer.js";
@@ -104,6 +105,11 @@ async function materializeStoreSurfaces(store, workspaceRoot, opts) {
 }
 // Artifacts that receive live timestamp substitution on first seed.
 const TIMESTAMPED_ARTIFACT_RELS = new Set(["agent-state/STATUS.md", "agent-state/EVIDENCE_LOG.md"]);
+const GATE_CONTRACT_OPERATIONAL_ARTIFACT_RELS = [
+    "agent-state/TEAL_CONFIG.md",
+    "agent-state/QUALITY_GATES.md",
+    "agent-state/INTERFACE_REGISTRY.md",
+];
 async function seedOperationalArtifacts(store) {
     const bootstrapTs = new Date().toISOString();
     for (const relPath of OPERATIONAL_ARTIFACT_REL_PATHS) {
@@ -117,8 +123,23 @@ async function seedOperationalArtifacts(store) {
         await store.setBlob(operationalArtifactKey(relPath), content);
     }
 }
+async function syncOperationalArtifacts(store, relPaths) {
+    for (const relPath of relPaths) {
+        const knowledgeKey = `knowledge/agent-state/${relPath.replace(/^agent-state\//, "")}`;
+        const content = (await store.getBlob(knowledgeKey)) ?? "";
+        await store.setBlob(operationalArtifactKey(relPath), content);
+    }
+}
+async function migrateExistingStoreGateContract(store, workspaceRoot, assetsRoot, warnings) {
+    const migration = await migratePackageGateContract(store, workspaceRoot, assetsRoot);
+    warnings.push(...migration.messages);
+    if (migration.changed) {
+        await syncOperationalArtifacts(store, GATE_CONTRACT_OPERATIONAL_ARTIFACT_RELS);
+    }
+}
 export async function bootstrapStoreWorkspace(opts) {
     const { workspaceRoot, force = false } = opts;
+    const assetsRoot = getAssetsRoot();
     const resolved = await ensureCanonicalWorkspaceStore(workspaceRoot, {
         operationLabel: "bootstrapStoreWorkspace",
     });
@@ -131,13 +152,14 @@ export async function bootstrapStoreWorkspace(opts) {
             return { storePath, agents: 0, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
         }
         if (existsSync(storePath) && !force) {
-            if (!(opts.includeMcpConfig ?? false) && !(opts.includeClientConfigBundle ?? false) && !opts.llm) {
-                warnings.push(`Store already exists at ${storePath}. Use --force to reinitialize, or run 'ace migrate' to import existing state.`);
-                return { storePath, agents: 0, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
-            }
             const existingStore = await openStore(storePath);
             try {
-                await seedOperationalArtifacts(existingStore);
+                await migrateExistingStoreGateContract(existingStore, workspaceRoot, assetsRoot, warnings);
+                if (!(opts.includeMcpConfig ?? false) && !(opts.includeClientConfigBundle ?? false) && !opts.llm) {
+                    const agents = (await existingStore.listAgents()).length;
+                    warnings.push(`Reused existing store at ${storePath}. Refreshed package gate contract state.`);
+                    return { storePath, agents, modules: { gates: 0, roles: 0, schemas: 0 }, materialized, warnings };
+                }
                 materialized.push(...(await materializeStoreSurfaces(existingStore, workspaceRoot, opts)));
                 const agents = (await existingStore.listAgents()).length;
                 warnings.push(`Reused existing store at ${storePath} and refreshed host materializations.`);
@@ -163,8 +185,8 @@ export async function bootstrapStoreWorkspace(opts) {
                 include_mcp_config: opts.includeMcpConfig ?? false,
                 include_client_config_bundle: opts.includeClientConfigBundle ?? false,
             });
-            const assetsRoot = getAssetsRoot();
             const knowledge = await bakeAllCoreKnowledge(store, assetsRoot);
+            await recordPackageGateContractVersion(store);
             await bakeTopology(store, assetsRoot);
             await store.setJSON("state/handoffs/__index", []);
             await store.setJSON("state/todo/index", []);
@@ -215,7 +237,9 @@ export async function repairWorkspace(workspaceRoot) {
     const { storePath } = resolved;
     const warnings = [...resolved.warnings];
     const store = await openStore(storePath);
+    const assetsRoot = getAssetsRoot();
     try {
+        await migrateExistingStoreGateContract(store, workspaceRoot, assetsRoot, warnings);
         const hostPolicy = (await store.getJSON("meta/host_materialization")) ?? {};
         // Re-materialize host files
         const hostMat = new HostFileMaterializer(store, workspaceRoot);

package/dist/store/gate-contract-migration.d.ts

@@ -0,0 +1,10 @@
+import type { IAcePackedStore } from "./types.js";
+export declare const PACKAGE_GATE_CONTRACT_VERSION = 2;
+export declare const PACKAGE_GATE_CONTRACT_VERSION_KEY = "meta/package_gate_contract_version";
+export interface GateContractMigrationResult {
+    changed: boolean;
+    messages: string[];
+}
+export declare function recordPackageGateContractVersion(store: IAcePackedStore): Promise<void>;
+export declare function migratePackageGateContract(store: IAcePackedStore, workspaceRoot: string, assetsRoot: string): Promise<GateContractMigrationResult>;
+//# sourceMappingURL=gate-contract-migration.d.ts.map