@opengsd/gsd-pi 1.2.0-dev.84c56d87 → 1.2.0-dev.8e6112e9

package/packages/mcp-server/dist/workflow-tools.js

@@ -10,6 +10,9 @@ import { pathToFileURL } from "node:url";
 import { z } from "zod";
 import { WORKFLOW_TOOL_NAMES as CONTRACT_WORKFLOW_TOOL_NAMES, CANONICAL_WORKFLOW_TOOL_NAMES as CONTRACT_CANONICAL_WORKFLOW_TOOL_NAMES, WORKFLOW_TOOL_ALIAS_NAMES as CONTRACT_WORKFLOW_TOOL_ALIAS_NAMES, } from "@opengsd/contracts";
 import { logAliasUsage } from "./alias-telemetry.js";
+async function importBridgeModule() {
+    return importLocalModule("../../../src/resources/extensions/gsd/mcp-bridge.js");
+}
 let workflowToolExecutorsPromise = null;
 let workflowExecutionQueue = Promise.resolve();
 let workflowWriteGatePromise = null;
@@ -283,7 +286,7 @@ function getWriteGateModuleCandidates() {
         warnCustomWorkflowModule("GSD_WORKFLOW_WRITE_GATE_MODULE", explicitModule);
         candidates.push(explicitModule.startsWith("file:") ? explicitModule : toFileUrl(explicitModule));
     }
-    candidates.push(...buildBridgeImportCandidates("../../../src/resources/extensions/gsd/bootstrap/write-gate.js")
+    candidates.push(...buildBridgeImportCandidates("../../../src/resources/extensions/gsd/mcp-bridge.js")
         .map((p) => new URL(p, import.meta.url).href));
     return [...new Set(candidates)];
 }
@@ -333,10 +336,27 @@ async function importLocalModule(relativePath) {
     }
     throw lastErr;
 }
+async function importWorkflowRuntimeModule(relativePath) {
+    const rawCandidates = import.meta.url.includes("/src/") || import.meta.url.includes("\\src\\")
+        ? _buildImportCandidates(relativePath)
+        : buildBridgeImportCandidates(relativePath);
+    const candidates = rawCandidates
+        .map((p) => new URL(p, import.meta.url).href);
+    let lastErr;
+    for (const candidate of candidates) {
+        try {
+            return await import(candidate);
+        }
+        catch (err) {
+            lastErr = err;
+        }
+    }
+    throw lastErr;
+}
 async function loadProjectPreferences(projectDir) {
-    const { loadEffectiveGSDPreferences } = await importLocalModule("../../../src/resources/extensions/gsd/preferences.js");
+    const bridge = await importBridgeModule();
     try {
-        return loadEffectiveGSDPreferences(projectDir).preferences;
+        return bridge.loadEffectiveGSDPreferences(projectDir).preferences;
     }
     catch {
         return null;
@@ -523,8 +543,8 @@ async function runSerializedWorkflowOperation(fn) {
 }
 async function runSerializedWorkflowDbOperation(projectDir, fn) {
     return runSerializedWorkflowOperation(async () => {
-        const { ensureDbOpen } = await importLocalModule("../../../src/resources/extensions/gsd/bootstrap/dynamic-tools.js");
-        const dbAvailable = await ensureDbOpen(projectDir);
+        const bridge = await importBridgeModule();
+        const dbAvailable = await bridge.ensureDbOpen(projectDir);
         if (!dbAvailable) {
             throw new Error("GSD database is not available");
         }
@@ -620,23 +640,22 @@ async function inferSaveGateResultScope(projectDir, prepared) {
         return out;
     if (!gateId)
         return out;
-    const { ensureDbOpen } = await importLocalModule("../../../src/resources/extensions/gsd/bootstrap/dynamic-tools.js");
-    if (!(await ensureDbOpen(projectDir)))
+    const bridge = await importBridgeModule();
+    if (!(await bridge.ensureDbOpen(projectDir)))
         return out;
-    const db = await importLocalModule("../../../src/resources/extensions/gsd/gsd-db.js");
-    if (!db.getMilestoneSlices || !db.getPendingGates || !db.getGateResults)
+    if (!bridge.getMilestoneSlices || !bridge.getPendingGates || !bridge.getGateResults)
         return out;
     const milestoneFilter = stringValue(out.milestoneId);
     const sliceFilter = stringValue(out.sliceId);
     const milestones = milestoneFilter
         ? [{ id: milestoneFilter }]
-        : (db.getAllMilestones?.() ?? []).filter((milestone) => stringValue(milestone.id));
+        : (bridge.getAllMilestones?.() ?? []).filter((milestone) => stringValue(milestone.id));
     const candidates = [];
     for (const milestone of milestones) {
         const milestoneId = stringValue(milestone.id);
         if (!milestoneId)
             continue;
-        const slices = db.getMilestoneSlices(milestoneId)
+        const slices = bridge.getMilestoneSlices(milestoneId)
             .filter((slice) => {
             const sliceId = stringValue(slice.id);
             return sliceId && (!sliceFilter || sliceId === sliceFilter);
@@ -646,8 +665,8 @@ async function inferSaveGateResultScope(projectDir, prepared) {
             if (!sliceId)
                 continue;
             const rows = [
-                ...db.getPendingGates(milestoneId, sliceId),
-                ...db.getGateResults(milestoneId, sliceId),
+                ...bridge.getPendingGates(milestoneId, sliceId),
+                ...bridge.getGateResults(milestoneId, sliceId),
             ];
             for (const row of rows) {
                 if (stringValue(row.gate_id)?.toUpperCase() !== gateId)
@@ -682,8 +701,8 @@ async function handleSaveGateResult(projectDir, args) {
 }
 async function ensureMilestoneDbRow(milestoneId) {
     try {
-        const { insertMilestone } = await importLocalModule("../../../src/resources/extensions/gsd/gsd-db.js");
-        insertMilestone({ id: milestoneId, status: "queued" });
+        const bridge = await importBridgeModule();
+        bridge.insertMilestone({ id: milestoneId, status: "queued" });
     }
     catch {
         // Ignore pre-existing rows or transient DB availability issues.
@@ -691,8 +710,8 @@ async function ensureMilestoneDbRow(milestoneId) {
 }
 async function findDatabaseMilestoneIds() {
     try {
-        const { getAllMilestones } = await importLocalModule("../../../src/resources/extensions/gsd/gsd-db.js");
-        return (getAllMilestones?.() ?? [])
+        const bridge = await importBridgeModule();
+        return (bridge.getAllMilestones?.() ?? [])
             .map((milestone) => {
             const id = milestone?.id;
             return typeof id === "string" ? id : null;
@@ -712,7 +731,8 @@ async function findDatabaseMilestoneIds() {
  * from an earlier call to this same tool.
  */
 async function generateOrReuseMilestoneId(projectDir) {
-    const { claimReservedId, findMilestoneIds, getReservedMilestoneIds, nextMilestoneId, milestoneIdSort, } = await importLocalModule("../../../src/resources/extensions/gsd/milestone-ids.js");
+    const bridge = await importBridgeModule();
+    const { claimReservedId, findMilestoneIds, getReservedMilestoneIds, nextMilestoneId, milestoneIdSort, } = bridge;
     const reserved = claimReservedId();
     if (reserved) {
         await ensureMilestoneDbRow(reserved);
@@ -726,7 +746,7 @@ async function generateOrReuseMilestoneId(projectDir) {
         ]),
     ];
     // Attempt ghost-ID reuse before falling back to max+1.
-    const { isReusableGhostMilestone } = await importLocalModule("../../../src/resources/extensions/gsd/state.js");
+    const { isReusableGhostMilestone } = bridge;
     const sorted = [...allIds].sort(milestoneIdSort);
     for (const candidate of sorted) {
         if (isReusableGhostMilestone(projectDir, candidate)) {
@@ -734,7 +754,7 @@ async function generateOrReuseMilestoneId(projectDir) {
             return candidate;
         }
     }
-    const prefsMod = await importLocalModule("../../../src/resources/extensions/gsd/preferences.js").catch(() => null);
+    const prefsMod = await importBridgeModule().catch(() => null);
     // Graceful degradation: a corrupt preferences file should not crash
     // milestone-id generation. Fall back to non-unique IDs if anything
     // throws here — matches the pre-fix behavior for missing prefs.
@@ -758,6 +778,71 @@ const projectDirParam = z
     .optional()
     .describe("Optional. Omit this field — the server defaults to its current working directory, which is already the correct project or worktree root.");
 const unknownRecord = z.record(z.string(), z.unknown());
+/** Split "id — detail" / "id - detail" pairs used by legacy string payloads. */
+function splitPair(value) {
+    const match = value.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
+    return match ? [match[1].trim(), match[2].trim()] : [value.trim(), ""];
+}
+/** Accept string or string[] at runtime; emit array-only JSON Schema (no anyOf). */
+const optionalStringOrStringArray = () => z.preprocess((value) => (value == null ? value : Array.isArray(value) ? value : [value]), z.array(z.string()).optional());
+function optionalStructuredStringArray(itemSchema, coerceString) {
+    return z.preprocess((value) => {
+        if (value == null)
+            return value;
+        if (!Array.isArray(value))
+            return value;
+        return value.map((item) => (typeof item === "string" ? coerceString(item) : item));
+    }, z.array(itemSchema).optional());
+}
+const requirementAdvancedItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [id, how] = splitPair(value);
+    return { id, how };
+}, z.object({ id: z.string(), how: z.string() }));
+const requirementValidatedItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [id, proof] = splitPair(value);
+    return { id, proof };
+}, z.object({ id: z.string(), proof: z.string() }));
+const requirementInvalidatedItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [id, what] = splitPair(value);
+    return { id, what };
+}, z.object({ id: z.string(), what: z.string() }));
+const filesModifiedItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [path, description] = splitPair(value);
+    return { path, description };
+}, z.object({ path: z.string(), description: z.string() }));
+const requiresItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [slice, provides] = splitPair(value);
+    return { slice, provides };
+}, z.object({ slice: z.string(), provides: z.string() }));
+// Accept either a string (legacy command-only form) or the structured object.
+// Mirrors `normalizeVerificationEvidence` in the executor: strings are coerced
+// into the canonical object shape before Zod validates, so the emitted JSON
+// Schema stays a single object type (no anyOf/oneOf) for Moonshot/Kimi.
+const verificationEvidenceItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    return {
+        command: value,
+        exitCode: -1,
+        verdict: "unknown (coerced from string)",
+        durationMs: 0,
+    };
+}, z.object({
+    command: z.string(),
+    exitCode: z.number(),
+    verdict: z.string(),
+    durationMs: z.number(),
+}));
 const nonEmptyString = (field) => z.string().trim().min(1, `${field} must be a non-empty string`);
 // Optional non-empty string: accepts omitted/undefined but rejects "" or
 // whitespace. Mirrors executor guards of the form
@@ -1003,34 +1088,34 @@ const sliceCompleteParams = {
     deviations: z.string().optional(),
     knownLimitations: z.string().optional(),
     followUps: z.string().optional(),
-    keyFiles: z.union([z.array(z.string()), z.string()]).optional(),
-    keyDecisions: z.union([z.array(z.string()), z.string()]).optional(),
-    patternsEstablished: z.union([z.array(z.string()), z.string()]).optional(),
-    observabilitySurfaces: z.union([z.array(z.string()), z.string()]).optional(),
-    provides: z.union([z.array(z.string()), z.string()]).optional(),
-    requirementsSurfaced: z.union([z.array(z.string()), z.string()]).optional(),
-    drillDownPaths: z.union([z.array(z.string()), z.string()]).optional(),
-    affects: z.union([z.array(z.string()), z.string()]).optional(),
-    requirementsAdvanced: z.array(z.union([
-        z.object({ id: z.string(), how: z.string() }),
-        z.string(),
-    ])).optional(),
-    requirementsValidated: z.array(z.union([
-        z.object({ id: z.string(), proof: z.string() }),
-        z.string(),
-    ])).optional(),
-    requirementsInvalidated: z.array(z.union([
-        z.object({ id: z.string(), what: z.string() }),
-        z.string(),
-    ])).optional(),
-    filesModified: z.array(z.union([
-        z.object({ path: z.string(), description: z.string() }),
-        z.string(),
-    ])).optional(),
-    requires: z.array(z.union([
-        z.object({ slice: z.string(), provides: z.string() }),
-        z.string(),
-    ])).optional(),
+    keyFiles: optionalStringOrStringArray(),
+    keyDecisions: optionalStringOrStringArray(),
+    patternsEstablished: optionalStringOrStringArray(),
+    observabilitySurfaces: optionalStringOrStringArray(),
+    provides: optionalStringOrStringArray(),
+    requirementsSurfaced: optionalStringOrStringArray(),
+    drillDownPaths: optionalStringOrStringArray(),
+    affects: optionalStringOrStringArray(),
+    requirementsAdvanced: optionalStructuredStringArray(requirementAdvancedItemSchema, (value) => {
+        const [id, how] = splitPair(value);
+        return { id, how };
+    }),
+    requirementsValidated: optionalStructuredStringArray(requirementValidatedItemSchema, (value) => {
+        const [id, proof] = splitPair(value);
+        return { id, proof };
+    }),
+    requirementsInvalidated: optionalStructuredStringArray(requirementInvalidatedItemSchema, (value) => {
+        const [id, what] = splitPair(value);
+        return { id, what };
+    }),
+    filesModified: optionalStructuredStringArray(filesModifiedItemSchema, (value) => {
+        const [path, description] = splitPair(value);
+        return { path, description };
+    }),
+    requires: optionalStructuredStringArray(requiresItemSchema, (value) => {
+        const [slice, provides] = splitPair(value);
+        return { slice, provides };
+    }),
 };
 const sliceCompleteSchema = z.object(sliceCompleteParams);
 export const _sliceCompleteSchemaForTest = sliceCompleteSchema;
@@ -1144,15 +1229,7 @@ const taskCompleteParams = {
         recommendationRationale: z.string().describe("Why the recommendation — 1-2 sentences."),
         continueWithDefault: z.boolean().describe("When true, the recommendation is recorded as the default, but auto-mode still pauses until the user resolves via /gsd escalate resolve."),
     }).optional().describe("ADR-011 Phase 2: optional escalation payload. Only honored when phases.mid_execution_escalation is true."),
-    verificationEvidence: z.array(z.union([
-        z.object({
-            command: z.string(),
-            exitCode: z.number(),
-            verdict: z.string(),
-            durationMs: z.number(),
-        }),
-        z.string(),
-    ])).optional().describe("Verification evidence entries"),
+    verificationEvidence: z.array(verificationEvidenceItemSchema).optional().describe("Verification evidence entries"),
 };
 const taskCompleteSchema = z.object(taskCompleteParams);
 const taskReopenParams = {
@@ -1277,7 +1354,11 @@ const uatResultSaveParams = {
     checks: z.array(uatCheckSchema).min(1).describe("Structured check results"),
     presentation: uatPresentationSchema.describe("Tool-presentation evidence"),
     notes: z.string().optional().describe("Overall verdict rationale"),
-    attempt: z.union([z.number().int().min(1), z.literal("auto")]).optional().describe("Attempt number or auto"),
+    // Accept number (e.g. 1) or string (e.g. "1", "auto") and coerce to string
+    // before validation, so the emitted JSON Schema stays a single primitive type
+    // (no anyOf/oneOf) for Moonshot/Kimi. The executor still treats "auto" and
+    // numeric strings as previously.
+    attempt: z.preprocess((value) => (typeof value === "number" ? String(value) : value), z.string().optional()).describe("Attempt number or auto"),
     previousAttemptId: z.string().optional(),
 };
 const uatResultSaveSchema = z.object(uatResultSaveParams);
@@ -1344,8 +1425,8 @@ export function registerWorkflowTools(realServer, options = {}) {
         const { projectDir, ...params } = parsed;
         await enforceWorkflowWriteGate("gsd_decision_save", projectDir);
         const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { saveDecisionToDb } = await importLocalModule("../../../src/resources/extensions/gsd/db-writer.js");
-            return saveDecisionToDb(params, projectDir);
+            const bridge = await importBridgeModule();
+            return bridge.saveDecisionToDb(params, projectDir);
         });
         return { content: [{ type: "text", text: `Saved decision ${result.id}` }] };
     });
@@ -1355,8 +1436,8 @@ export function registerWorkflowTools(realServer, options = {}) {
         const { projectDir, ...params } = parsed;
         await enforceWorkflowWriteGate("gsd_decision_save", projectDir);
         const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { saveDecisionToDb } = await importLocalModule("../../../src/resources/extensions/gsd/db-writer.js");
-            return saveDecisionToDb(params, projectDir);
+            const bridge = await importBridgeModule();
+            return bridge.saveDecisionToDb(params, projectDir);
         });
         return { content: [{ type: "text", text: `Saved decision ${result.id}` }] };
     });
@@ -1365,8 +1446,8 @@ export function registerWorkflowTools(realServer, options = {}) {
         const { projectDir, id, ...updates } = parsed;
         await enforceWorkflowWriteGate("gsd_requirement_update", projectDir);
         await runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { updateRequirementInDb } = await importLocalModule("../../../src/resources/extensions/gsd/db-writer.js");
-            return updateRequirementInDb(id, updates, projectDir);
+            const bridge = await importBridgeModule();
+            return bridge.updateRequirementInDb(id, updates, projectDir);
         });
         return { content: [{ type: "text", text: `Updated requirement ${id}` }] };
     });
@@ -1376,8 +1457,8 @@ export function registerWorkflowTools(realServer, options = {}) {
         const { projectDir, id, ...updates } = parsed;
         await enforceWorkflowWriteGate("gsd_requirement_update", projectDir);
         await runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { updateRequirementInDb } = await importLocalModule("../../../src/resources/extensions/gsd/db-writer.js");
-            return updateRequirementInDb(id, updates, projectDir);
+            const bridge = await importBridgeModule();
+            return bridge.updateRequirementInDb(id, updates, projectDir);
         });
         return { content: [{ type: "text", text: `Updated requirement ${id}` }] };
     });
@@ -1386,8 +1467,8 @@ export function registerWorkflowTools(realServer, options = {}) {
         const { projectDir, ...params } = parsed;
         await enforceWorkflowWriteGate("gsd_requirement_save", projectDir);
         const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { saveRequirementToDb } = await importLocalModule("../../../src/resources/extensions/gsd/db-writer.js");
-            return saveRequirementToDb(params, projectDir);
+            const bridge = await importBridgeModule();
+            return bridge.saveRequirementToDb(params, projectDir);
         });
         return { content: [{ type: "text", text: `Saved requirement ${result.id}` }] };
     });
@@ -1397,8 +1478,8 @@ export function registerWorkflowTools(realServer, options = {}) {
         const { projectDir, ...params } = parsed;
         await enforceWorkflowWriteGate("gsd_requirement_save", projectDir);
         const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { saveRequirementToDb } = await importLocalModule("../../../src/resources/extensions/gsd/db-writer.js");
-            return saveRequirementToDb(params, projectDir);
+            const bridge = await importBridgeModule();
+            return bridge.saveRequirementToDb(params, projectDir);
         });
         return { content: [{ type: "text", text: `Saved requirement ${result.id}` }] };
     });
@@ -1499,14 +1580,13 @@ export function registerWorkflowTools(realServer, options = {}) {
         await enforceWorkflowWriteGate("gsd_skip_slice", projectDir, milestoneId);
         await runSerializedWorkflowDbOperation(projectDir, async () => {
             const { handleSkipSlice } = await importLocalModule("../../../src/resources/extensions/gsd/tools/skip-slice.js");
-            const { invalidateStateCache } = await importLocalModule("../../../src/resources/extensions/gsd/state.js");
-            const { rebuildState } = await importLocalModule("../../../src/resources/extensions/gsd/doctor.js");
+            const bridge = await importBridgeModule();
             const result = handleSkipSlice({ milestoneId, sliceId, reason });
             if (result.error) {
                 throw new Error(result.error);
             }
-            invalidateStateCache();
-            await rebuildState(projectDir);
+            bridge.invalidateStateCache();
+            await bridge.rebuildState(projectDir);
         });
         return {
             content: [{ type: "text", text: `Skipped slice ${sliceId} (${milestoneId}). Reason: ${reason ?? "User-directed skip"}.` }],
@@ -1634,8 +1714,8 @@ export function registerWorkflowTools(realServer, options = {}) {
     server.tool("gsd_checkpoint_db", "Flush the SQLite WAL into gsd.db so git add stages the current GSD database state.", checkpointDbParams, async (args) => {
         const { projectDir } = parseWorkflowArgs(checkpointDbSchema, args);
         await runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { checkpointDatabase } = await importLocalModule("../../../src/resources/extensions/gsd/gsd-db.js");
-            checkpointDatabase();
+            const bridge = await importBridgeModule();
+            bridge.checkpointDatabase();
         });
         return {
             content: [{
@@ -1647,8 +1727,8 @@ export function registerWorkflowTools(realServer, options = {}) {
     });
     server.tool("gsd_journal_query", "Query the structured event journal for auto-mode iterations.", journalQueryParams, async (args) => {
         const { projectDir, limit, ...filters } = parseWorkflowArgs(journalQuerySchema, args);
-        const { queryJournal } = await importLocalModule("../../../src/resources/extensions/gsd/journal.js");
-        const entries = queryJournal(projectDir, filters).slice(0, limit ?? 100);
+        const bridge = await importBridgeModule();
+        const entries = bridge.queryJournal(projectDir, filters).slice(0, limit ?? 100);
         if (entries.length === 0) {
             return { content: [{ type: "text", text: "No matching journal entries found." }] };
         }
@@ -1727,7 +1807,7 @@ export function registerWorkflowTools(realServer, options = {}) {
         const { projectDir, ...params } = parseWorkflowArgs(captureThoughtSchema, args);
         await enforceWorkflowWriteGate("gsd_capture_thought", projectDir);
         return runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { executeMemoryCapture } = await importLocalModule("../../../src/resources/extensions/gsd/tools/memory-tools.js");
+            const { executeMemoryCapture } = await importWorkflowRuntimeModule("../../../src/resources/extensions/gsd/tools/memory-tools.js");
             return executeMemoryCapture(params);
         });
     });
@@ -1756,7 +1836,7 @@ export function registerWorkflowTools(realServer, options = {}) {
     server.tool("gsd_memory_query", "Search the GSD memory store by keyword. Returns ranked memories with id, category, content, confidence, scope, and tags. Mirrors the in-process memory_query tool for external MCP clients.", memoryQueryParams, async (args) => {
         const { projectDir, ...params } = parseWorkflowArgs(memoryQuerySchema, args);
         return runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { executeMemoryQuery } = await importLocalModule("../../../src/resources/extensions/gsd/tools/memory-tools.js");
+            const { executeMemoryQuery } = await importWorkflowRuntimeModule("../../../src/resources/extensions/gsd/tools/memory-tools.js");
             return executeMemoryQuery(params);
         });
     });
@@ -1777,7 +1857,7 @@ export function registerWorkflowTools(realServer, options = {}) {
     server.tool("gsd_memory_graph", "Inspect the relationship graph between memories. mode=query walks edges from a given memoryId. mode=build is a placeholder reserved for future graph rebuilds. Distinct from gsd_graph (project knowledge graph) — see ADR-013.", memoryGraphParams, async (args) => {
         const { projectDir, ...params } = parseWorkflowArgs(memoryGraphSchema, args);
         return runSerializedWorkflowDbOperation(projectDir, async () => {
-            const { executeGsdGraph } = await importLocalModule("../../../src/resources/extensions/gsd/tools/memory-tools.js");
+            const { executeGsdGraph } = await importWorkflowRuntimeModule("../../../src/resources/extensions/gsd/tools/memory-tools.js");
             return executeGsdGraph(params);
         });
     });