@voybio/ace-swarm 2.4.3 → 2.4.6

package/dist/public-surface.js

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { PACKAGE_ROOT, resolveWorkspaceRoot } from "./helpers.js";
+import { PACKAGE_ROOT, resolveWorkspaceRoot, safeWrite } from "./helpers.js";
 import { EVENT_TYPE } from "./shared.js";
 export const PUBLIC_SURFACE_REPORT_REL_PATH = "agent-state/PUBLIC_SURFACE_REPORT.md";
 const SCHEMA_REQUIREMENTS = {
@@ -116,13 +116,6 @@ function workspaceRoot() {
 function reportPath(relPath = PUBLIC_SURFACE_REPORT_REL_PATH) {
     return resolve(workspaceRoot(), relPath);
 }
-function safeWriteReport(filePath, content) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmpPath, content, "utf-8");
-    renameSync(tmpPath, filePath);
-    return filePath;
-}
 async function collectSurfaceEntries() {
     const entries = [];
     const [{ registerTools }, { registerResources }, { registerPrompts }] = await Promise.all([
@@ -162,7 +155,7 @@ async function collectSurfaceEntries() {
     registerPrompts(stub);
     return entries.sort((left, right) => left.id.localeCompare(right.id));
 }
-function walkTypescriptFiles(root) {
+function walkRuntimeSourceFiles(root) {
     const files = [];
     const visit = (dirPath) => {
         const entries = readdirSync(dirPath, { withFileTypes: true });
@@ -176,8 +169,9 @@ function walkTypescriptFiles(root) {
                 visit(absolutePath);
                 continue;
             }
-            if (extname(entry.name) === ".ts")
+            if ([".ts", ".js"].includes(extname(entry.name)) && !entry.name.endsWith(".d.ts")) {
                 files.push(absolutePath);
+            }
         }
     };
     visit(root);
@@ -185,7 +179,7 @@ function walkTypescriptFiles(root) {
 }
 function collectEmittedEventTypes() {
     const srcRoot = dirname(fileURLToPath(import.meta.url));
-    const files = walkTypescriptFiles(srcRoot);
+    const files = walkRuntimeSourceFiles(srcRoot);
     const discovered = new Set();
     const patterns = [
         /event_type:\s*"([A-Z][A-Z0-9_]+)"/g,
@@ -272,10 +266,24 @@ export function auditPublicSurface(options) {
                 const packageAbs = resolve(PACKAGE_ROOT, "assets", relPath);
                 if (!existsSync(abs) && !existsSync(packageAbs)) {
                     failures.push(`schema file missing for ${surfaceId}: ${relPath}`);
+                    continue;
+                }
+                const schemaPath = existsSync(abs) ? abs : packageAbs;
+                try {
+                    const schema = JSON.parse(readFileSync(schemaPath, "utf-8"));
+                    if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+                        failures.push(`schema file is not a JSON object for ${surfaceId}: ${relPath}`);
+                    }
+                }
+                catch (error) {
+                    failures.push(`schema file is invalid JSON for ${surfaceId}: ${relPath} (${error instanceof Error ? error.message : String(error)})`);
                 }
             }
         }
         const eventRegistry = new Set(Object.values(EVENT_TYPE));
+        if (emittedEvents.length === 0) {
+            failures.push("no emitted event types discovered in the production runtime sources");
+        }
         for (const eventType of emittedEvents) {
             if (!eventRegistry.has(eventType)) {
                 failures.push(`event type emitted without shared registry entry: ${eventType}`);
@@ -292,7 +300,8 @@ export function auditPublicSurface(options) {
             emitted_events: emittedEvents.length,
             schema_bound_surfaces: Object.keys(SCHEMA_REQUIREMENTS).length,
         };
-        const report_path = reportPath(options?.artifact_path || PUBLIC_SURFACE_REPORT_REL_PATH);
+        const artifactRelPath = options?.artifact_path || PUBLIC_SURFACE_REPORT_REL_PATH;
+        const report_path = reportPath(artifactRelPath);
         const result = {
             ok: failures.length === 0,
             summary,
@@ -301,8 +310,9 @@ export function auditPublicSurface(options) {
             surfaces,
             emitted_events: emittedEvents,
         };
+        let written_path;
         if (options?.write_artifact !== false) {
-            safeWriteReport(report_path, renderReport(result));
+            written_path = safeWrite(artifactRelPath, renderReport(result));
         }
         else if (!existsSync(report_path)) {
             warnings.push(`public surface report missing: ${report_path}`);
@@ -310,6 +320,8 @@ export function auditPublicSurface(options) {
         return {
             ...result,
             report_path,
+            artifact_path: artifactRelPath,
+            written_path,
         };
     });
 }

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/safe-edit.d.ts

@@ -7,6 +7,8 @@ export interface SafeEditInput {
     path: string;
     /** New file content. */
     content: string;
+    /** Optional full sha256:<hex> source precondition checked immediately before promotion. */
+    expected_base_hash?: string;
     /** Shell command to validate the change (e.g., "npx tsc --noEmit"). */
     validation_command?: string;
     /** Shell command to run tests (e.g., "npm test"). */
@@ -26,6 +28,11 @@ export interface SafeEditResult {
     test_passed?: boolean;
     test_output?: string;
     error?: string;
+    reason_code?: string;
+    expected_hash?: string;
+    observed_hash?: string;
+    lease_lock_path?: string;
+    lease_waited_ms?: number;
     restored?: boolean;
 }
 export interface TestSuiteResult {
@@ -43,6 +50,18 @@ export interface DiffResult {
     removed: number;
     diff_summary: string;
 }
+export interface GcStagingInput {
+    max_age_hours?: number;
+    max_entries?: number;
+}
+export interface GcStagingResult {
+    ok: boolean;
+    staging_path: string;
+    removed_entries: number;
+    kept_entries: number;
+    errors: string[];
+}
+export declare function gcStaging(input?: GcStagingInput): GcStagingResult;
 export declare function safeEditFile(input: SafeEditInput): SafeEditResult;
 export declare function runTestSuite(command?: string): TestSuiteResult;
 export declare function diffContents(original: string, updated: string): DiffResult;
@@ -52,6 +71,7 @@ export declare function diffFiles(pathA: string, pathB: string): DiffResult & {
 export interface ApplyPatchInput {
     path: string;
     patch: string;
+    expected_base_hash?: string;
     validation_command?: string;
     test_command?: string;
 }