@wowok/agent-mcp 2.3.14 → 2.3.16

package/dist/index.js

@@ -5,13 +5,18 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { readFileSync } from "fs";
 import { resolve } from "path";
 const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
-import { MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, BridgeOperationsSchema, BridgeCallOutputSchema, OnchainOperationsSchema, WipOperationsSchema, OnchainTableDataSchema, OnchainTableDataResultSchema, WatchQueryOperationsSchema, } from "./schema/index.js";
+import { MachineNode2File_InputSchema, MachineNode2File_OutputWrappedSchema, Guard2File_InputSchema, Guard2File_OutputWrappedSchema, strictParse, CallOutputSchema, handleCallResult, createServerConfig, createCapabilitiesConfig, createToolMeta, transformSubmission, getEnvConfig, OnchainEventsInputSchema, OnchainEventsResultSchema, ProtocolInfoQuerySchema, ProtocolInfoResultSchema, AccountOperationOutputWrappedSchema, LocalMarkOperationOutputWrappedSchema, LocalInfoOperationOutputWrappedSchema, WipOperationOutputSchema, MessengerOperationOutputSchema, AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, MessengerOperationInputSchema, BridgeOperationsSchema, BridgeCallOutputSchema, OnchainOperationsSchema, WipOperationsSchema, OnchainTableDataSchema, OnchainTableDataResultSchema, WatchQueryOperationsSchema, registerSuccessHook, } from "./schema/index.js";
 import { handleBridgeOperations } from "./schema/call/bridge-handler.js";
 import { buildDataSemantic, classifyError } from "./schema/call/semantic.js";
 import { getHarness } from "./harness/index.js";
-const HARNESS_ENABLED = process.env.WOWOK_HARNESS_ENABLED === "1" || process.env.WOWOK_HARNESS_ENABLED === "true";
+import { confirmGate } from "./safety/confirm-gate.js";
+import { renderPreview } from "./safety/preview.js";
+import { isProjectServiceEnabled, normalize as projectNormalize, observe as projectObserve, queryProjects, queryProjectObjects, queryShareableObjects, queryDependencies, queryReferencedBy, queryPrePublishCheck, queryCrossProjectReferences, queryGraphStats, saveGraph, loadGraph, } from "./project/index.js";
+import { isEnabled as isRuntimeEnabled, listServices, getServiceInfo, toggle as toggleService, setEnabled as setServiceEnabled, reset as resetService, } from "./config/index.js";
+import { validateOperation, hasBlockingViolations, getWarningViolations, } from "./knowledge/index.js";
+const HARNESS_ENABLED = () => isRuntimeEnabled("harness");
 function withHarness(base, operation, intent) {
-    if (!HARNESS_ENABLED)
+    if (!HARNESS_ENABLED())
         return base;
     try {
         const harness = getHarness();
@@ -27,6 +32,58 @@ function withHarness(base, operation, intent) {
         return base;
     }
 }
+function buildPendingConfirmation(operation_type, data, env) {
+    const gate = confirmGate(operation_type, data, env, env?.user_intent_phrases);
+    if (gate.pass)
+        return { content: [], structuredContent: null };
+    const preview = gate.preview;
+    const rendered = renderPreview(preview);
+    const output = {
+        message: rendered,
+        result: {
+            type: "pending_confirmation",
+            preview,
+            rule_id: gate.rule_id,
+        },
+        semantic: {
+            intent: `${operation_type}_awaiting_confirmation`,
+            status: "pending_input",
+            summary: `Operation blocked by ConfirmGate (${gate.level}). Review the preview and re-call with env.confirmed=true to proceed.`,
+            next_actions: [
+                {
+                    action: "confirm: re-call the SAME operation with env.confirmed=true",
+                    reason: `ConfirmGate rule '${gate.rule_id}' matched. The operation was NOT executed.`,
+                    tool: "onchain_operations",
+                    priority: "required",
+                },
+            ],
+            warnings: preview.warnings ?? [],
+        },
+    };
+    return {
+        content: [{ type: "text", text: rendered }],
+        structuredContent: output,
+    };
+}
+function buildConstraintError(operation_type, violations) {
+    const errors = violations.filter((v) => v.severity === "error");
+    const errorList = errors.map((v) => `  • [${v.field}] ${v.message}`).join("\n");
+    const message = `Pre-call constraint violations for '${operation_type}':\n${errorList}\n\nFix the listed field(s) and retry.`;
+    const output = {
+        message,
+        result: {
+            type: "error",
+            error: message,
+            error_code: "invalid_parameter",
+            retryable: false,
+            recovery_hint: "Review the constraint violations above and correct the corresponding fields.",
+        },
+    };
+    return {
+        content: [{ type: "text", text: message }],
+        structuredContent: output,
+    };
+}
 import { CallService, CallMachine, CallProgress, CallPermission, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, guard2file, parseGuardFile, formatGuardParseErrors, machineNode2file, generateNodeComments, generate_wip, verify_wip, sign_wip, wip2html, account_operation, local_mark_operation, local_info_operation, watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, pull_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, query_local_mark_list, query_account_list, query_local_info_list, query_local_token_list, query_account, GetLocalNamesByAddresses, query_personal, query_objects, query_table, query_tableItem, queryProtocolInfo, query_received, queryTableItem_RepositoryData, queryTableItem_PermissionPerm, queryTableItem_RewardRecord, queryTableItem_DemandPresenter, queryTableItem_TreasuryHistory, queryTableItem_MachineNode, queryTableItem_ProgressHistory, queryTableItem_AddressMark, queryTableItem_EntityRegistrar, queryTableItem_EntityLinker, query_events, blacklist, friendslist, guardlist, settings, AmountType, } from "@wowok/wowok";
 import { areSchemasAvailable, getSchemaIndex, processSchemaQuery, } from "./schema-query/index.js";
 const SERVER_DESCRIPTION = `WoWok MCP Server - Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.
@@ -141,8 +198,73 @@ import { withTelemetry, setTelemetryEnabled } from "./telemetry/index.js";
 if (process.env.WOWOK_TELEMETRY === "false" || process.env.WOWOK_TELEMETRY === "0") {
     setTelemetryEnabled(false);
 }
-function reg(name, config, handler) {
-    server.registerTool(name, config, withTelemetry(name, handler));
+function buildClassifiedErrorResult(base, error, classified) {
+    const result = { ...base, error };
+    if (classified.error_code !== undefined)
+        result.error_code = classified.error_code;
+    if (classified.retryable !== undefined)
+        result.retryable = classified.retryable;
+    if (classified.recovery_hint !== undefined)
+        result.recovery_hint = classified.recovery_hint;
+    return result;
+}
+const statusErrorShape = (error, classified, ctx) => ({
+    result: buildClassifiedErrorResult({ status: "error" }, error, classified),
+    semantic: buildDataSemantic(undefined, ctx, true, error),
+});
+const operationErrorShape = (error, classified, ctx) => ({
+    result: buildClassifiedErrorResult({ operation: "error" }, error, classified),
+    semantic: buildDataSemantic(undefined, ctx, true, error),
+});
+const strictStatusErrorShape = (error, _classified, _ctx) => ({
+    result: { status: "error", error },
+});
+function reg(name, config, handler, errorShapeBuilder, customTimeoutMs) {
+    const timeoutMs = customTimeoutMs ?? 60000;
+    const wrappedHandler = wrapHandlerWithErrorShape(handler, timeoutMs, name, errorShapeBuilder);
+    server.registerTool(name, config, withTelemetry(name, wrappedHandler));
+}
+function withTimeout(promise, timeoutMs = 30000, operationName = "operation") {
+    let timer;
+    return Promise.race([
+        promise.finally(() => {
+            if (timer)
+                clearTimeout(timer);
+        }),
+        new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                let hint = "";
+                if (operationName.includes("messenger")) {
+                    hint = " This is a messenger network operation. Possible causes: " +
+                        "(1) messenger server (https://messenger.wowok.net) unreachable, " +
+                        "(2) no messenger-enabled account configured (use account_operation to set messenger name), " +
+                        "(3) network connectivity issue. " +
+                        "Ensure you have a messenger-enabled account and the server is reachable.";
+                }
+                reject(new Error(`Operation '${operationName}' timed out after ${timeoutMs}ms.${hint}`));
+            }, timeoutMs);
+        }),
+    ]);
+}
+function wrapHandlerWithErrorShape(handler, timeoutMs, toolName, errorShapeBuilder) {
+    return async (args) => {
+        try {
+            return await withTimeout(handler(args), timeoutMs, toolName);
+        }
+        catch (error) {
+            if (errorShapeBuilder) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const classified = classifyError(errorMessage);
+                const ctx = { operation_type: toolName, data: args };
+                const structuredContent = errorShapeBuilder(errorMessage, classified, ctx);
+                return {
+                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    structuredContent,
+                };
+            }
+            throw error;
+        }
+    };
 }
 function convertAmountType(type) {
     if (typeof type === "number")
@@ -261,6 +383,7 @@ async function handleOnchainTableData(args) {
 }
 async function handleOnchainOperations(args) {
     let validated;
+    let constraintWarnings = [];
     try {
         if (typeof args === 'object' && args !== null && args.description && !args.operation_type) {
             const hasWrappedParams = typeof args.description === 'string' &&
@@ -273,6 +396,29 @@ async function handleOnchainOperations(args) {
         }
         validated = strictParse(OnchainOperationsSchema, args, "onchain_operations input");
         const env = getEnvConfig(validated.env);
+        const gateResult = buildPendingConfirmation(validated.operation_type, validated.data, env);
+        if (gateResult.structuredContent) {
+            return gateResult;
+        }
+        const constraintViolations = validateOperation(validated.operation_type, validated.data);
+        if (hasBlockingViolations(constraintViolations)) {
+            return buildConstraintError(validated.operation_type, constraintViolations);
+        }
+        constraintWarnings = getWarningViolations(constraintViolations).map((v) => `[PRE-CHECK] ${v.message}`);
+        const projectEnvPrefix = env?.project;
+        if (isProjectServiceEnabled()) {
+            const pn = projectNormalize({
+                operation_type: validated.operation_type,
+                data: validated.data,
+                projectPrefix: projectEnvPrefix,
+            });
+            validated.data = pn.data;
+        }
+        if (env && typeof env === "object") {
+            delete env.confirmed;
+            delete env.user_intent_phrases;
+            delete env.project;
+        }
         switch (validated.operation_type) {
             case "service": {
                 const callService = new CallService(validated.data);
@@ -281,7 +427,7 @@ async function handleOnchainOperations(args) {
                     : await callService.call(env);
                 const data = validated.data;
                 const intent = data?.publish ? "publish service" : data?.bPublished !== undefined ? "modify service" : "create service";
-                return handleCallResult(result, withHarness({ operation_type: validated.operation_type, data }, "service", intent));
+                return handleCallResult(result, withHarness({ operation_type: validated.operation_type, data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined }, "service", intent));
             }
             case "machine": {
                 if (validated.data.node && typeof validated.data.node === 'object' && 'json_or_markdown_file' in validated.data.node) {
@@ -312,42 +458,42 @@ async function handleOnchainOperations(args) {
                 const result = validated.submission
                     ? await callMachine.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callMachine.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "progress": {
                 const callProgress = new CallProgress(validated.data);
                 const result = validated.submission
                     ? await callProgress.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callProgress.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "repository": {
                 const callRepository = new CallRepository(validated.data);
                 const result = validated.submission
                     ? await callRepository.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callRepository.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "arbitration": {
                 const callArbitration = new CallArbitration(validated.data);
                 const result = validated.submission
                     ? await callArbitration.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callArbitration.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "contact": {
                 const callContact = new CallContact(validated.data);
                 const result = validated.submission
                     ? await callContact.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callContact.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "treasury": {
                 const callTreasury = new CallTreasury(validated.data);
                 const result = validated.submission
                     ? await callTreasury.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callTreasury.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "reward": {
                 const transformedData = transformRewardData(validated.data);
@@ -355,19 +501,19 @@ async function handleOnchainOperations(args) {
                 const result = validated.submission
                     ? await callReward.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callReward.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "allocation": {
                 const callAllocation = new CallAllocation(validated.data);
                 const result = validated.submission
                     ? await callAllocation.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callAllocation.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "permission": {
                 const callPermission = new CallPermission(validated.data);
                 const result = await callPermission.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "guard": {
                 const validatedData = validated.data;
@@ -414,7 +560,7 @@ async function handleOnchainOperations(args) {
                 }
                 const callGuard = new CallGuard(validatedData);
                 const result = await callGuard.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "personal": {
                 const transformPersonalData = (data) => {
@@ -467,48 +613,48 @@ async function handleOnchainOperations(args) {
                 const transformedData = transformPersonalData(validated.data);
                 const callPersonal = new CallPersonal(transformedData);
                 const result = await callPersonal.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "payment": {
                 const callPayment = new CallPayment(validated.data);
                 const result = await callPayment.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "demand": {
                 const callDemand = new CallDemand(validated.data);
                 const result = validated.submission
                     ? await callDemand.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callDemand.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "order": {
                 const callOrder = new CallOrder(validated.data);
                 const result = validated.submission
                     ? await callOrder.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callOrder.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "gen_passport": {
                 const result = await gen_passport(env, validated.guard, validated.info);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "proof": {
                 const callProof = new CallProof(validated.data);
                 const result = validated.submission
                     ? await callProof.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callProof.call(env);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
             case "gen_proof": {
                 const result = await gen_proof(env, validated.proof, validated.server_pubkey, validated.server_signature, validated.proof_type, validated.description, validated.item_count, validated.about_address);
-                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data });
+                return handleCallResult(result, { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined });
             }
         }
         throw new Error(`Unknown on-chain operation type: ${validated.operation_type}`);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        return handleCallResult({ error: errorMessage }, validated ? { operation_type: validated.operation_type, data: validated.data } : undefined);
+        return handleCallResult({ error: errorMessage }, validated ? { operation_type: validated.operation_type, data: validated.data, pre_warnings: constraintWarnings.length ? constraintWarnings : undefined } : undefined);
     }
 }
 async function handleAccountOperation(args) {
@@ -532,16 +678,20 @@ async function handleAccountOperation(args) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const ctx = validated ? { operation_type: "account_" + validated.operation_type, data: validated } : undefined;
         const classified = classifyError(errorMessage);
+        const errorResult = {
+            status: "error",
+            error: errorMessage,
+        };
+        if (classified.error_code !== undefined)
+            errorResult.error_code = classified.error_code;
+        if (classified.retryable !== undefined)
+            errorResult.retryable = classified.retryable;
+        if (classified.recovery_hint !== undefined)
+            errorResult.recovery_hint = classified.recovery_hint;
         return {
             content: [{ type: "text", text: `Error: ${errorMessage}` }],
             structuredContent: {
-                result: {
-                    status: "error",
-                    error: errorMessage,
-                    error_code: classified.error_code,
-                    retryable: classified.retryable,
-                    recovery_hint: classified.recovery_hint,
-                },
+                result: errorResult,
                 semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
             },
         };
@@ -568,16 +718,17 @@ async function handleMarkOperation(args) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const ctx = validated ? { operation_type: "mark_" + validated.operation_type, data: validated } : undefined;
         const classified = classifyError(errorMessage);
+        const errorResult = { status: "error", error: errorMessage };
+        if (classified.error_code !== undefined)
+            errorResult.error_code = classified.error_code;
+        if (classified.retryable !== undefined)
+            errorResult.retryable = classified.retryable;
+        if (classified.recovery_hint !== undefined)
+            errorResult.recovery_hint = classified.recovery_hint;
         return {
             content: [{ type: "text", text: `Error: ${errorMessage}` }],
             structuredContent: {
-                result: {
-                    status: "error",
-                    error: errorMessage,
-                    error_code: classified.error_code,
-                    retryable: classified.retryable,
-                    recovery_hint: classified.recovery_hint,
-                },
+                result: errorResult,
                 semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
             },
         };
@@ -604,16 +755,17 @@ async function handleInfoOperation(args) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const ctx = validated ? { operation_type: "local_info", data: validated } : undefined;
         const classified = classifyError(errorMessage);
+        const errorResult = { status: "error", error: errorMessage };
+        if (classified.error_code !== undefined)
+            errorResult.error_code = classified.error_code;
+        if (classified.retryable !== undefined)
+            errorResult.retryable = classified.retryable;
+        if (classified.recovery_hint !== undefined)
+            errorResult.recovery_hint = classified.recovery_hint;
         return {
             content: [{ type: "text", text: `Error: ${errorMessage}` }],
             structuredContent: {
-                result: {
-                    status: "error",
-                    error: errorMessage,
-                    error_code: classified.error_code,
-                    retryable: classified.retryable,
-                    recovery_hint: classified.recovery_hint,
-                },
+                result: errorResult,
                 semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
             },
         };
@@ -780,168 +932,304 @@ async function handleOnchainEvents(args) {
         },
     };
 }
-function normalizeAccountOrMark(input) {
-    if (typeof input === 'string') {
-        return { name_or_address: input, local_mark_first: true };
-    }
-    return input;
-}
-function normalizeManyAccountOrMark(input) {
-    if (Array.isArray(input)) {
-        return {
-            entities: input.map(item => typeof item === 'string' ? { name_or_address: item, local_mark_first: true } : item),
-            check_all_founded: true
-        };
-    }
-    return input;
-}
-async function handleMessengerOperation(args) {
-    const validated = strictParse(MessengerOperationInputSchema, args, "messenger_operation input");
+async function handleProjectOperation(args) {
+    const action = args.action;
+    const project = args.project;
+    const object = args.object;
     let result;
-    switch (validated.operation) {
-        case "watch_conversations": {
-            const conversations = await watch_conversations(validated.filter);
-            result = { operation: "watch_conversations", result: conversations };
+    switch (action) {
+        case "list_projects":
+            result = await queryProjects();
             break;
-        }
-        case "send_message": {
-            const sendResult = await send_message(validated.from, normalizeAccountOrMark(validated.to), validated.content, validated.options);
-            const filteredResult = {
-                ...sendResult,
-                merkleData: sendResult.merkleData ? {
-                    leafIndex: sendResult.merkleData.leafIndex,
-                    prevRoot: sendResult.merkleData.prevRoot,
-                    newRoot: sendResult.merkleData.newRoot,
-                    serverSignature: sendResult.merkleData.serverSignature,
-                    serverTimestamp: sendResult.merkleData.serverTimestamp,
-                    serverPublicKey: sendResult.merkleData.serverPublicKey,
-                } : undefined,
-            };
-            result = { operation: "send_message", result: filteredResult };
+        case "list_objects":
+            if (!project)
+                throw new Error("'project' param is required for list_objects");
+            result = await queryProjectObjects(project);
             break;
-        }
-        case "send_file": {
-            const sendResult = await send_file(validated.from, normalizeAccountOrMark(validated.to), validated.filePath, validated.options);
-            const filteredResult = {
-                ...sendResult,
-                merkleData: sendResult.merkleData ? {
-                    leafIndex: sendResult.merkleData.leafIndex,
-                    prevRoot: sendResult.merkleData.prevRoot,
-                    newRoot: sendResult.merkleData.newRoot,
-                    serverSignature: sendResult.merkleData.serverSignature,
-                    serverTimestamp: sendResult.merkleData.serverTimestamp,
-                    serverPublicKey: sendResult.merkleData.serverPublicKey,
-                } : undefined,
-            };
-            result = { operation: "send_file", result: filteredResult };
+        case "shareable":
+            result = await queryShareableObjects();
             break;
-        }
-        case "watch_messages": {
-            const filter = validated.filter ? {
-                ...validated.filter,
-                peerAddress: validated.filter.peerAddress ? normalizeAccountOrMark(validated.filter.peerAddress) : undefined
-            } : undefined;
-            const messages = await watch_messages(filter);
-            result = { operation: "watch_messages", result: messages };
+        case "dependencies":
+            if (!object)
+                throw new Error("'object' param is required for dependencies");
+            result = queryDependencies(object);
             break;
-        }
-        case "extract_zip_messages": {
-            const extractedPaths = await extract_zip_messages(validated.account, validated.messages, validated.outputDir);
-            result = { operation: "extract_zip_messages", result: extractedPaths };
+        case "referenced_by":
+            if (!object)
+                throw new Error("'object' param is required for referenced_by");
+            result = queryReferencedBy(object);
             break;
-        }
-        case "generate_wts": {
-            const params = validated.params ? {
-                ...validated.params,
-                peerAccount: normalizeAccountOrMark(validated.params.peerAccount)
-            } : undefined;
-            const wtsResult = await generate_wts(params);
-            result = { operation: "generate_wts", result: wtsResult };
+        case "pre_publish_check":
+            if (!object)
+                throw new Error("'object' param is required for pre_publish_check");
+            result = { warnings: queryPrePublishCheck(object) };
             break;
-        }
-        case "verify_wts": {
-            const verifyResult = await verify_wts(validated.wtsFilePath);
-            result = { operation: "verify_wts", result: verifyResult };
+        case "cross_project_refs":
+            result = queryCrossProjectReferences();
             break;
-        }
-        case "sign_wts": {
-            const signedPath = await sign_wts(validated.wtsFilePath, validated.account, validated.outputPath);
-            result = { operation: "sign_wts", result: signedPath };
+        case "graph_stats":
+            result = queryGraphStats();
             break;
-        }
-        case "wts2html": {
-            const htmlResult = await wts2html(validated.wtsPath, validated.options);
-            result = { operation: "wts2html", result: htmlResult };
+        case "save_graph":
+            result = { saved: true, path: saveGraph() };
             break;
-        }
-        case "proof_message": {
-            const proofResult = await proof_message(validated.account, validated.messageId, validated.network);
-            result = { operation: "proof_message", result: proofResult };
+        case "load_graph":
+            result = { loaded: loadGraph() };
             break;
-        }
-        case "blacklist": {
-            const blacklistParams = {
-                account: validated.account,
-                op: validated.blacklist.op
-            };
-            if ('users' in validated.blacklist) {
-                blacklistParams.users = normalizeManyAccountOrMark(validated.blacklist.users);
-            }
-            const blacklistResult = await blacklist(blacklistParams);
-            result = { operation: "blacklist", op: validated.blacklist.op, result: blacklistResult.result };
+        default:
+            throw new Error(`Unknown project_operation action: ${action}`);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
+        structuredContent: { result },
+    };
+}
+async function handleConfigOperation(args) {
+    const action = args.action;
+    let result;
+    switch (action) {
+        case "list":
+            result = { services: listServices() };
             break;
-        }
-        case "friendslist": {
-            const friendslistParams = {
-                account: validated.account,
-                op: validated.friendslist.op
-            };
-            if ('users' in validated.friendslist) {
-                friendslistParams.users = normalizeManyAccountOrMark(validated.friendslist.users);
+        case "toggle": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for toggle");
+            const validServices = ["confirm_gate", "project_service", "harness", "graph_persist", "semantic_rich"];
+            if (!validServices.includes(service)) {
+                throw new Error(`Unknown service: ${service}. Valid: ${validServices.join(", ")}`);
             }
-            const friendslistResult = await friendslist(friendslistParams);
-            result = { operation: "friendslist", op: validated.friendslist.op, result: friendslistResult.result };
+            const newState = toggleService(service);
+            const info = getServiceInfo(service);
+            result = { service, enabled: newState, reminder: info?.reminder };
             break;
         }
-        case "guardlist": {
-            const guardlistResult = await guardlist({
-                account: validated.account,
-                ...validated.guardlist
-            });
-            result = { operation: "guardlist", op: validated.guardlist.op, result: guardlistResult.result };
+        case "enable": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for enable");
+            setServiceEnabled(service, true);
+            const info = getServiceInfo(service);
+            result = { service, enabled: true, reminder: info?.reminder };
             break;
         }
-        case "settings": {
-            const settingsResult = await settings({
-                account: validated.account,
-                ...validated.settings
-            });
-            result = { operation: "settings", op: validated.settings.op, result: settingsResult.result };
+        case "disable": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for disable");
+            setServiceEnabled(service, false);
+            const info = getServiceInfo(service);
+            result = { service, enabled: false, reminder: info?.reminder };
             break;
         }
-        case "mark_messages_as_viewed": {
-            const markedCount = await mark_messages_as_viewed(validated.messageIds, validated.account);
-            result = { operation: "mark_messages_as_viewed", result: markedCount };
+        case "reset": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for reset");
+            resetService(service);
+            const info = getServiceInfo(service);
+            result = { service, enabled: info?.enabled, reminder: info?.reminder, reset: true };
             break;
         }
-        case "mark_conversation_as_viewed": {
-            const markedCount = await mark_conversation_as_viewed(normalizeAccountOrMark(validated.peerAddress), validated.account);
-            result = { operation: "mark_conversation_as_viewed", result: markedCount };
-            break;
-        }
-        case "pull_messages": {
-            const messages = await pull_messages(validated.account, validated.limit);
-            result = { operation: "pull_messages", result: messages };
+        case "info": {
+            const service = args.service;
+            if (!service)
+                throw new Error("'service' param is required for info");
+            result = getServiceInfo(service);
             break;
         }
         default:
-            throw new Error(`Unknown messenger operation: ${validated.operation}`);
+            throw new Error(`Unknown config_operation action: ${action}`);
     }
     return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
+        content: [{ type: "text", text: JSON.stringify({ result }) }],
         structuredContent: { result },
     };
 }
+function normalizeAccountOrMark(input) {
+    if (typeof input === 'string') {
+        return { name_or_address: input, local_mark_first: true };
+    }
+    return input;
+}
+function normalizeManyAccountOrMark(input) {
+    if (Array.isArray(input)) {
+        return {
+            entities: input.map(item => typeof item === 'string' ? { name_or_address: item, local_mark_first: true } : item),
+            check_all_founded: true
+        };
+    }
+    return input;
+}
+async function handleMessengerOperation(args) {
+    let validated;
+    try {
+        validated = strictParse(MessengerOperationInputSchema, args, "messenger_operation input");
+        let result;
+        switch (validated.operation) {
+            case "watch_conversations": {
+                const conversations = await watch_conversations(validated.filter);
+                result = { operation: "watch_conversations", result: conversations };
+                break;
+            }
+            case "send_message": {
+                const sendResult = await send_message(validated.from, normalizeAccountOrMark(validated.to), validated.content, validated.options);
+                const filteredResult = {
+                    ...sendResult,
+                    merkleData: sendResult.merkleData ? {
+                        leafIndex: sendResult.merkleData.leafIndex,
+                        prevRoot: sendResult.merkleData.prevRoot,
+                        newRoot: sendResult.merkleData.newRoot,
+                        serverSignature: sendResult.merkleData.serverSignature,
+                        serverTimestamp: sendResult.merkleData.serverTimestamp,
+                        serverPublicKey: sendResult.merkleData.serverPublicKey,
+                    } : undefined,
+                };
+                result = { operation: "send_message", result: filteredResult };
+                break;
+            }
+            case "send_file": {
+                const sendResult = await send_file(validated.from, normalizeAccountOrMark(validated.to), validated.filePath, validated.options);
+                const filteredResult = {
+                    ...sendResult,
+                    merkleData: sendResult.merkleData ? {
+                        leafIndex: sendResult.merkleData.leafIndex,
+                        prevRoot: sendResult.merkleData.prevRoot,
+                        newRoot: sendResult.merkleData.newRoot,
+                        serverSignature: sendResult.merkleData.serverSignature,
+                        serverTimestamp: sendResult.merkleData.serverTimestamp,
+                        serverPublicKey: sendResult.merkleData.serverPublicKey,
+                    } : undefined,
+                };
+                result = { operation: "send_file", result: filteredResult };
+                break;
+            }
+            case "watch_messages": {
+                const filter = validated.filter ? {
+                    ...validated.filter,
+                    peerAddress: validated.filter.peerAddress ? normalizeAccountOrMark(validated.filter.peerAddress) : undefined
+                } : undefined;
+                const messages = await watch_messages(filter);
+                result = { operation: "watch_messages", result: messages };
+                break;
+            }
+            case "extract_zip_messages": {
+                const extractedPaths = await extract_zip_messages(validated.account, validated.messages, validated.outputDir);
+                result = { operation: "extract_zip_messages", result: extractedPaths };
+                break;
+            }
+            case "generate_wts": {
+                const params = validated.params ? {
+                    ...validated.params,
+                    peerAccount: normalizeAccountOrMark(validated.params.peerAccount)
+                } : undefined;
+                const wtsResult = await generate_wts(params);
+                result = { operation: "generate_wts", result: wtsResult };
+                break;
+            }
+            case "verify_wts": {
+                const verifyResult = await verify_wts(validated.wtsFilePath);
+                result = { operation: "verify_wts", result: verifyResult };
+                break;
+            }
+            case "sign_wts": {
+                const signedPath = await sign_wts(validated.wtsFilePath, validated.account, validated.outputPath);
+                result = { operation: "sign_wts", result: signedPath };
+                break;
+            }
+            case "wts2html": {
+                const htmlResult = await wts2html(validated.wtsPath, validated.options);
+                result = { operation: "wts2html", result: htmlResult };
+                break;
+            }
+            case "proof_message": {
+                const proofResult = await proof_message(validated.account, validated.messageId, validated.network);
+                result = { operation: "proof_message", result: proofResult };
+                break;
+            }
+            case "blacklist": {
+                const blacklistParams = {
+                    account: validated.account,
+                    op: validated.blacklist.op
+                };
+                if ('users' in validated.blacklist) {
+                    blacklistParams.users = normalizeManyAccountOrMark(validated.blacklist.users);
+                }
+                const blacklistResult = await blacklist(blacklistParams);
+                result = { operation: "blacklist", op: validated.blacklist.op, result: blacklistResult.result };
+                break;
+            }
+            case "friendslist": {
+                const friendslistParams = {
+                    account: validated.account,
+                    op: validated.friendslist.op
+                };
+                if ('users' in validated.friendslist) {
+                    friendslistParams.users = normalizeManyAccountOrMark(validated.friendslist.users);
+                }
+                const friendslistResult = await friendslist(friendslistParams);
+                result = { operation: "friendslist", op: validated.friendslist.op, result: friendslistResult.result };
+                break;
+            }
+            case "guardlist": {
+                const guardlistResult = await guardlist({
+                    account: validated.account,
+                    ...validated.guardlist
+                });
+                result = { operation: "guardlist", op: validated.guardlist.op, result: guardlistResult.result };
+                break;
+            }
+            case "settings": {
+                const settingsResult = await settings({
+                    account: validated.account,
+                    ...validated.settings
+                });
+                result = { operation: "settings", op: validated.settings.op, result: settingsResult.result };
+                break;
+            }
+            case "mark_messages_as_viewed": {
+                const markedCount = await mark_messages_as_viewed(validated.messageIds, validated.account);
+                result = { operation: "mark_messages_as_viewed", result: markedCount };
+                break;
+            }
+            case "mark_conversation_as_viewed": {
+                const markedCount = await mark_conversation_as_viewed(normalizeAccountOrMark(validated.peerAddress), validated.account);
+                result = { operation: "mark_conversation_as_viewed", result: markedCount };
+                break;
+            }
+            case "pull_messages": {
+                const messages = await pull_messages(validated.account, validated.limit);
+                result = { operation: "pull_messages", result: messages };
+                break;
+            }
+            default:
+                throw new Error(`Unknown messenger operation: ${validated.operation}`);
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: { result },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const ctx = validated ? { operation_type: "messenger_" + validated.operation, data: validated } : undefined;
+        const classified = classifyError(errorMessage);
+        const errorResult = { operation: "error", error: errorMessage };
+        if (classified.error_code !== undefined)
+            errorResult.error_code = classified.error_code;
+        if (classified.retryable !== undefined)
+            errorResult.retryable = classified.retryable;
+        if (classified.recovery_hint !== undefined)
+            errorResult.recovery_hint = classified.recovery_hint;
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            structuredContent: {
+                result: errorResult,
+                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
+            },
+        };
+    }
+}
 async function handleGuard2File(args) {
     const validated = strictParse(Guard2File_InputSchema, args, "guard2file input");
     const env = getEnvConfig(validated.env);
@@ -980,6 +1268,24 @@ async function handleMachineNode2File(args) {
     const env = getEnvConfig(validated.env);
     try {
         await machineNode2file(validated.machine, validated.file_path, validated.format || "json", env.network);
+        let node_count = undefined;
+        try {
+            const filePath = resolve(validated.file_path);
+            const fileContent = await import('fs/promises').then(fs => fs.readFile(filePath, 'utf-8'));
+            if ((validated.format || "json") === "json") {
+                const parsed = JSON.parse(fileContent);
+                if (Array.isArray(parsed)) {
+                    node_count = parsed.length;
+                }
+            }
+            else {
+                const nodeMatches = fileContent.match(/^##\s+Node:/gm);
+                node_count = nodeMatches ? nodeMatches.length : 0;
+            }
+        }
+        catch {
+            node_count = undefined;
+        }
         const result = {
             result: {
                 status: "success",
@@ -987,10 +1293,12 @@ async function handleMachineNode2File(args) {
                     file_path: resolve(validated.file_path),
                     format: validated.format || "json",
                     machine_object: validated.machine,
-                    node_count: 0,
                 },
             },
         };
+        if (node_count !== undefined) {
+            result.result.data.node_count = node_count;
+        }
         return {
             content: [{ type: "text", text: JSON.stringify(result) }],
             structuredContent: result,
@@ -1020,6 +1328,16 @@ async function main() {
     else {
         console.error("Schema files not available. Run 'npm run generate:schemas' to generate them.");
     }
+    if (isProjectServiceEnabled()) {
+        registerSuccessHook((result, context) => {
+            if (context?.operation_type && context?.data) {
+                projectObserve(context.operation_type, context.data, result);
+            }
+        });
+        console.error("ProjectService enabled — object graph observe active");
+    }
+    const activeServices = listServices().filter((s) => s.enabled).map((s) => s.name);
+    console.error(`Phase 2 active services: ${activeServices.join(", ") || "none"}`);
     reg("onchain_operations", {
         title: "⛓️ On-chain Operations",
         description: "On-chain operations for WoWok object: service (marketplace listings), machine (workflow templates), progress (order tracking), repository (on-chain database), arbitration (dispute resolution), contact (IM management), treasury (team funds), reward (incentive pools), allocation (auto-distribution), permission (access control), guard (programmable trust rules), personal (public profile), payment (direct coin transfers), demand (service requests), order (order management), gen_passport (verified credentials), proof (on-chain proof objects), gen_proof (generate proof shortcut).",
@@ -1035,7 +1353,7 @@ async function main() {
         outputSchema: AccountOperationOutputWrappedSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("operation", ["account", "local", "private", "wallet", "off-chain"]),
-    }, handleAccountOperation);
+    }, handleAccountOperation, statusErrorShape);
     reg("local_mark_operation", {
         title: "🔒 LOCAL ONLY: LocalMark - Address Book Management",
         description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage ID names and tags stored ONLY on your local device for easy identification of user address or object IDs by name.",
@@ -1043,7 +1361,7 @@ async function main() {
         outputSchema: LocalMarkOperationOutputWrappedSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("operation", ["mark", "local", "private", "address-book", "off-chain"]),
-    }, handleMarkOperation);
+    }, handleMarkOperation, statusErrorShape);
     reg("local_info_operation", {
         title: "🔒 LOCAL ONLY: LocalInfo - Private Data Management",
         description: "100% LOCAL, NEVER ON-CHAIN 🔒 Manage sensitive personal information stored ONLY on your device: delivery addresses, phone numbers, contacts.",
@@ -1051,7 +1369,7 @@ async function main() {
         outputSchema: LocalInfoOperationOutputWrappedSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
         _meta: createToolMeta("operation", ["info", "local", "private", "data-management", "off-chain"]),
-    }, handleInfoOperation);
+    }, handleInfoOperation, statusErrorShape);
     reg("wip_file", {
         title: "🤝 Witness Immutable Promise File Operations",
         description: "generate (create WIP files from markdown and images), verify (integrity check), sign (add signatures), or wip2html (convert to HTML).",
@@ -1069,7 +1387,7 @@ async function main() {
         outputSchema: MessengerOperationOutputSchema,
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
         _meta: createToolMeta("operation", ["messenger", "message", "file", "wts", "blacklist", "friendslist", "guardlist", "settings", "proof", "communication"]),
-    }, handleMessengerOperation);
+    }, handleMessengerOperation, operationErrorShape, 30000);
     reg("guard2file", {
         title: "📄 Guard to File - Export Guard Definition",
         description: "Export a Guard object's definition from the blockchain to a local JSON or Markdown file for editing and creating new Guard objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
@@ -1077,7 +1395,7 @@ async function main() {
         outputSchema: Guard2File_OutputWrappedSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("generate file", ["guard", "export", "file", "json", "markdown", "on-chain"]),
-    }, handleGuard2File);
+    }, handleGuard2File, strictStatusErrorShape);
     reg("machineNode2file", {
         title: "⚙️ Machine Node to File - Export Machine Node Definition",
         description: "Export a Machine object's node definition from the blockchain to a local JSON or Markdown file for editing and creating new Machine objects. Note: To query on-chain object information, use the 'query_toolkit' tool instead.",
@@ -1085,7 +1403,7 @@ async function main() {
         outputSchema: MachineNode2File_OutputWrappedSchema,
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("generate file", ["machine", "export", "file", "json", "markdown", "on-chain", "workflow"]),
-    }, handleMachineNode2File);
+    }, handleMachineNode2File, strictStatusErrorShape);
     reg("query_toolkit", {
         title: "🔍 Data Query Toolkit",
         description: "WOWOK data query toolkit — 9 query types covering local device data and on-chain blockchain data:\n\n"
@@ -1103,7 +1421,8 @@ async function main() {
             + "For dynamic table data queries (pagination, table items), use the 'onchain_table_data' tool.",
         inputSchema: WatchQueryOperationsSchema,
         outputSchema: z.object({
-            result: z.any().describe("Query result — type depends on query_type. Local queries return arrays (MarkData[], AccountData[], InfoData[], TokenTypeInfo[]). account_balance returns { address, balance? | coin? }. Onchain queries return typed objects or undefined. onchain_received returns ReceivedBalance | ReceivedNormal[].")
+            result: z.unknown().describe("Query result — type depends on query_type. Local queries return arrays (MarkData[], AccountData[], InfoData[], TokenTypeInfo[]). account_balance returns { address, balance? | coin? }. Onchain queries return typed objects or undefined. onchain_received returns ReceivedBalance | ReceivedNormal[]."),
+            semantic: z.unknown().optional().describe("Business semantic summary for the query operation"),
         }),
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         _meta: createToolMeta("query", ["watch", "query", "on-chain", "local", "events", "objects", "tokens", "balance", "profile"]),
@@ -1285,6 +1604,71 @@ async function main() {
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
         _meta: createToolMeta("operation", ["bridge", "cross-chain", "evm", "ethereum", "wow", "transfer", "rpc"]),
     }, handleBridgeOperations);
+    reg("project_operation", {
+        title: "🗂️ Project - Namespace & Object Graph",
+        description: "Phase 2 project namespace service — manage and query the local object dependency graph (DAG) " +
+            "built on top of local_mark tags. No on-chain writes; all data comes from local marks tagged " +
+            "`project:<prefix>` (auto-injected by the ProjectService when enabled, default ON).\n\n" +
+            "Actions:\n" +
+            "  • list_projects — List all discovered projects (grouped by `project:<prefix>` tag) with object counts.\n" +
+            "  • list_objects — List objects in a project (requires `project` param).\n" +
+            "  • shareable — List objects tagged `shareable:true` (cross-project reusable: common Permission, 3rd-party Arb).\n" +
+            "  • dependencies — Trace forward dependencies of an object (BFS transitive closure + dangling refs).\n" +
+            "  • referenced_by — Reverse query: who references this object?\n" +
+            "  • pre_publish_check — Pre-publish sanity check for a service (dangling deps + cycles).\n" +
+            "  • cross_project_refs — Find edges that cross project boundaries.\n" +
+            "  • graph_stats — Graph statistics (node/edge counts, cycles, dangling deps).\n" +
+            "  • save_graph — Save the in-memory graph to ~/.wowok/project-graph.json (persist across sessions).\n" +
+            "  • load_graph — Load the graph from file (restore after restart).\n\n" +
+            "NOTE: The graph is in-memory by default. Use save_graph/load_graph for cross-session persistence " +
+            "(or toggle graph_persist via config_operation for auto-save). " +
+            "list_projects/shareable always query local_mark (persistent).",
+        inputSchema: z.object({
+            action: z.enum([
+                "list_projects", "list_objects", "shareable",
+                "dependencies", "referenced_by", "pre_publish_check",
+                "cross_project_refs", "graph_stats",
+                "save_graph", "load_graph",
+            ]).describe("Query/action to perform"),
+            project: z.string().optional().describe("Project prefix (for list_objects)"),
+            object: z.string().optional().describe("Object name or address (for dependencies / referenced_by / pre_publish_check)"),
+        }),
+        outputSchema: z.object({
+            result: z.any().describe("Query result — shape depends on action"),
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("project", ["project", "namespace", "graph", "dag", "dependency", "reference", "organization"]),
+    }, handleProjectOperation);
+    reg("config_operation", {
+        title: "⚙️ Config - Runtime Service Toggles",
+        description: "Phase 2 runtime configuration — toggle Phase 2 services on/off at runtime WITHOUT restarting the MCP server. " +
+            "This is the session-level switch mechanism: AI can toggle based on user conversation context, or users can " +
+            "directly control which Phase 2 features are active.\n\n" +
+            "Actions:\n" +
+            "  • list — List all services with current state + reminders.\n" +
+            "  • toggle — Toggle a service on/off (requires `service` param). Returns reminder text.\n" +
+            "  • enable — Enable a service (requires `service` param).\n" +
+            "  • disable — Disable a service (requires `service` param).\n" +
+            "  • reset — Reset a service to its default (requires `service` param).\n" +
+            "  • info — Get detailed info about a service (requires `service` param).\n\n" +
+            "Services:\n" +
+            "  • confirm_gate — Safety Confirmation Gate (default ON)\n" +
+            "  • project_service — Project Namespace + Dependency Graph (default ON)\n" +
+            "  • harness — L4 Verify/Recover Loop (default OFF)\n" +
+            "  • graph_persist — Graph Persistence to File (default OFF)\n" +
+            "  • semantic_rich — Semantic Layer Enrichment Reminder (default ON)\n\n" +
+            "NOTE: Toggles persist for the MCP process lifetime. Set WOWOK_RUNTIME_CONFIG_PERSIST=1 " +
+            "to persist across sessions to ~/.wowok/runtime-config.json.",
+        inputSchema: z.object({
+            action: z.enum(["list", "toggle", "enable", "disable", "reset", "info"]).describe("Config action to perform"),
+            service: z.string().optional().describe("Service name (required for toggle/enable/disable/reset/info)"),
+        }),
+        outputSchema: z.object({
+            result: z.any().describe("Config result — shape depends on action"),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        _meta: createToolMeta("config", ["config", "toggle", "service", "runtime", "switch", "enable", "disable"]),
+    }, handleConfigOperation);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     process.on("SIGINT", async () => {