@deftai/directive-core 0.92.0 → 0.94.0

package/dist/check/consumer-gate-integrity.js

@@ -0,0 +1,265 @@
+/**
+ * Consumer check-graph integrity (#3070).
+ *
+ * CONSUMER_CHECK_GATES lists Taskfile tasks that must resolve in a vendored
+ * deposit. When optional Taskfile includes silently omit `tasks/verify.yml`
+ * (etc.), go-task fails with opaque exit 200/201 ("Task does not exist").
+ *
+ * This module:
+ *  1. Maps each gate to its include namespace / root Taskfile surface
+ *  2. Proves shipped files define those tasks (static + runtime)
+ *  3. Emits a deposit-repair recovery message instead of opaque go-task errors
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { CONSUMER_CHECK_GATES, checkGateId } from "./gate-lists.js";
+/** Include namespaces required by the consumer check graph (Taskfile includes). */
+export const CHECK_GRAPH_REQUIRED_NAMESPACES = ["verify", "toolchain", "vbrief"];
+export const CONSUMER_GATE_INTEGRITY_RECOVERY = "Incomplete Deft deposit: check-graph Taskfile include(s) missing or incomplete. " +
+    "Run `deft update` (or `npm i -g @deftai/directive@latest` then `deft update`) " +
+    "to restore `.deft/core/tasks/` (including `tasks/verify.yml` for `verify:orphan-active`). " +
+    "See UPGRADING.md.";
+/** Namespace for a namespaced task (`verify:orphan-active` → `verify`); null for root tasks. */
+export function gateNamespace(gateId) {
+    const colon = gateId.indexOf(":");
+    if (colon <= 0) {
+        return null;
+    }
+    return gateId.slice(0, colon);
+}
+/** Local task name inside an include (`verify:orphan-active` → `orphan-active`). */
+export function gateLocalName(gateId) {
+    const colon = gateId.indexOf(":");
+    if (colon <= 0) {
+        return gateId;
+    }
+    return gateId.slice(colon + 1);
+}
+/** Relative path of the include Taskfile for a namespace. */
+export function includeTaskfileRel(namespace) {
+    return `tasks/${namespace}.yml`;
+}
+/**
+ * Namespaces that CONSUMER_CHECK_GATES require via `ns:task` form.
+ * Root-only gates (doctor, verify-strategy-output) do not add a namespace.
+ */
+export function requiredNamespacesForGates(gates = CONSUMER_CHECK_GATES) {
+    const seen = new Set();
+    for (const spec of gates) {
+        const ns = gateNamespace(checkGateId(spec));
+        if (ns !== null) {
+            seen.add(ns);
+        }
+    }
+    return [...seen].sort();
+}
+/** True when `localName` is a top-level task key under a Taskfile `tasks:` section. */
+export function taskDefinedInTaskfileYaml(text, localName) {
+    // go-task task keys are indented two spaces under `tasks:`.
+    // Match `  orphan-active:` / `  check-consumer:` etc., not nested keys.
+    const escaped = localName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`^ {2}${escaped}\\s*:`, "m");
+    return re.test(text.replace(/\r\n/g, "\n").replace(/\r/g, "\n"));
+}
+/**
+ * Parse root Taskfile `includes:` entries: map namespace → { taskfile, optional }.
+ * Minimal line parser (avoids a YAML dependency); sufficient for go-task include shape.
+ */
+export function parseTaskfileIncludes(text) {
+    const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+    const result = new Map();
+    let inIncludes = false;
+    let includesIndent = 0;
+    let currentNs = null;
+    let currentTaskfile = null;
+    let currentOptional = true; // go-task default when omitted is false, but our deposit historically used true
+    const flush = () => {
+        if (currentNs !== null && currentTaskfile !== null) {
+            result.set(currentNs, { taskfile: currentTaskfile, optional: currentOptional });
+        }
+        currentNs = null;
+        currentTaskfile = null;
+        currentOptional = false;
+    };
+    for (const raw of lines) {
+        const stripped = raw.trim();
+        if (!stripped || stripped.startsWith("#")) {
+            continue;
+        }
+        const indent = raw.length - raw.trimStart().length;
+        if (!inIncludes) {
+            if (/^includes\s*:/.test(stripped) && indent === 0) {
+                inIncludes = true;
+                includesIndent = indent;
+            }
+            continue;
+        }
+        if (indent <= includesIndent && !stripped.startsWith("#")) {
+            flush();
+            inIncludes = false;
+            // fall through if a new top-level key; re-check next iteration naturally
+            if (/^includes\s*:/.test(stripped)) {
+                inIncludes = true;
+                includesIndent = indent;
+            }
+            continue;
+        }
+        // Namespace key at includes+2 (typically 2 spaces): `  verify:`
+        if (indent === includesIndent + 2 && /^[A-Za-z_][\w-]*\s*:/.test(stripped)) {
+            flush();
+            currentNs = stripped.replace(/:\s*(?:#.*)?$/, "").trim();
+            currentTaskfile = null;
+            currentOptional = false;
+            continue;
+        }
+        if (currentNs === null) {
+            continue;
+        }
+        // Properties at includes+4: taskfile / optional
+        if (indent >= includesIndent + 4) {
+            const taskfileMatch = stripped.match(/^taskfile\s*:\s*["']?([^"'#]+?)["']?\s*(?:#.*)?$/i);
+            if (taskfileMatch?.[1]) {
+                currentTaskfile = taskfileMatch[1].trim();
+                continue;
+            }
+            const optionalMatch = stripped.match(/^optional\s*:\s*(true|false)\s*(?:#.*)?$/i);
+            if (optionalMatch?.[1]) {
+                currentOptional = optionalMatch[1].toLowerCase() === "true";
+            }
+        }
+    }
+    flush();
+    return result;
+}
+/**
+ * Assert every consumer check gate resolves against `frameworkRoot` Taskfile + includes.
+ * When the root Taskfile is absent, returns ok with no findings (caller/spawn handles that).
+ */
+export function evaluateConsumerGateIntegrity(frameworkRoot, seams = {}) {
+    const root = resolve(frameworkRoot);
+    const exists = seams.exists ?? ((p) => existsSync(p));
+    const readText = seams.readText ??
+        ((p) => {
+            try {
+                if (!existsSync(p)) {
+                    return null;
+                }
+                return readFileSync(p, "utf8");
+            }
+            catch {
+                return null;
+            }
+        });
+    const gates = seams.gates ?? CONSUMER_CHECK_GATES;
+    const findings = [];
+    const rootTaskfile = join(root, "Taskfile.yml");
+    if (!exists(rootTaskfile)) {
+        // Incomplete / non-deposit path: do not invent a Taskfile; let spawn fail as before.
+        return { ok: true, findings: [], recovery: CONSUMER_GATE_INTEGRITY_RECOVERY };
+    }
+    const rootText = readText(rootTaskfile);
+    if (rootText === null) {
+        findings.push({
+            gateId: "*",
+            kind: "missing-root-taskfile",
+            detail: `Taskfile.yml unreadable at ${rootTaskfile}`,
+            expectedPath: rootTaskfile,
+        });
+        return { ok: false, findings, recovery: CONSUMER_GATE_INTEGRITY_RECOVERY };
+    }
+    const includes = parseTaskfileIncludes(rootText);
+    const yamlCache = new Map();
+    const readCached = (abs) => {
+        if (yamlCache.has(abs)) {
+            return yamlCache.get(abs) ?? null;
+        }
+        const t = readText(abs);
+        yamlCache.set(abs, t);
+        return t;
+    };
+    yamlCache.set(rootTaskfile, rootText);
+    for (const spec of gates) {
+        const gateId = checkGateId(spec);
+        const ns = gateNamespace(gateId);
+        const local = gateLocalName(gateId);
+        if (ns === null) {
+            // Root Taskfile task (doctor, verify-strategy-output, …)
+            if (!taskDefinedInTaskfileYaml(rootText, local)) {
+                findings.push({
+                    gateId,
+                    kind: "missing-task-definition",
+                    detail: `Root task "${local}" not defined in Taskfile.yml (required by consumer check gate "${gateId}")`,
+                    expectedPath: rootTaskfile,
+                });
+            }
+            continue;
+        }
+        const rel = includeTaskfileRel(ns);
+        const includeMeta = includes.get(ns);
+        const relFromInclude = includeMeta?.taskfile ? includeMeta.taskfile.replace(/^\.\//, "") : rel;
+        const includeAbs = join(root, relFromInclude);
+        if (!exists(includeAbs)) {
+            findings.push({
+                gateId,
+                kind: "missing-include-file",
+                detail: `Missing Taskfile include file for namespace "${ns}" (gate "${gateId}"): ` +
+                    `${relFromInclude}. Optional silent omit of this include causes go-task ` +
+                    `"Task \\"${gateId}\\" does not exist" (exit 200/201).`,
+                expectedPath: includeAbs,
+            });
+            continue;
+        }
+        const includeText = readCached(includeAbs);
+        if (includeText === null) {
+            findings.push({
+                gateId,
+                kind: "missing-include-file",
+                detail: `Unreadable Taskfile include for namespace "${ns}": ${relFromInclude}`,
+                expectedPath: includeAbs,
+            });
+            continue;
+        }
+        if (!taskDefinedInTaskfileYaml(includeText, local)) {
+            findings.push({
+                gateId,
+                kind: "missing-task-definition",
+                detail: `Task "${local}" not defined in ${relFromInclude} (required by consumer check gate "${gateId}")`,
+                expectedPath: includeAbs,
+            });
+        }
+    }
+    return {
+        ok: findings.length === 0,
+        findings,
+        recovery: CONSUMER_GATE_INTEGRITY_RECOVERY,
+    };
+}
+/** Format integrity failure for stderr (check orchestrator / doctor). */
+export function formatConsumerGateIntegrityFailure(result) {
+    const lines = [
+        "check: consumer gate integrity failed (#3070)",
+        ...result.findings.map((f) => `  - ${f.gateId}: ${f.detail}`),
+        `  recovery: ${result.recovery}`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/**
+ * Namespaces that must not be `optional: true` on the root Taskfile when the
+ * check graph depends on them — silent omit is the #3070 failure mode.
+ */
+export function checkGraphOptionalIncludeViolations(rootTaskfileText, namespaces = requiredNamespacesForGates()) {
+    const includes = parseTaskfileIncludes(rootTaskfileText);
+    const bad = [];
+    for (const ns of namespaces) {
+        const meta = includes.get(ns);
+        if (meta === undefined) {
+            bad.push(`${ns} (include entry missing)`);
+            continue;
+        }
+        if (meta.optional) {
+            bad.push(`${ns} (optional: true — check-graph includes must fail loud when file is missing)`);
+        }
+    }
+    return bad;
+}
+//# sourceMappingURL=consumer-gate-integrity.js.map

package/dist/check/index.d.ts

@@ -1,4 +1,5 @@
 export { dispatchCachedTaskCheck } from "./cached-orchestrator.js";
+export { CHECK_GRAPH_REQUIRED_NAMESPACES, CONSUMER_GATE_INTEGRITY_RECOVERY, type ConsumerGateIntegrityFinding, type ConsumerGateIntegrityResult, type ConsumerGateIntegritySeams, checkGraphOptionalIncludeViolations, evaluateConsumerGateIntegrity, formatConsumerGateIntegrityFailure, gateLocalName, gateNamespace, includeTaskfileRel, parseTaskfileIncludes, requiredNamespacesForGates, taskDefinedInTaskfileYaml, } from "./consumer-gate-integrity.js";
 export { type CheckGateSpec, CONSUMER_CHECK_GATES, checkGateId, checkGateSpawnArgs, FRAMEWORK_CHECK_GATES, gatesForCheckTarget, } from "./gate-lists.js";
 export type { CheckOrchestratorOptions, CheckOrchestratorSeams } from "./orchestrator.js";
 export { dispatchTaskCheck, isFrameworkRepoRoot, isFrameworkSourceContext, resolveCheckTarget, } from "./orchestrator.js";

package/dist/check/index.js

@@ -1,4 +1,5 @@
 export { dispatchCachedTaskCheck } from "./cached-orchestrator.js";
+export { CHECK_GRAPH_REQUIRED_NAMESPACES, CONSUMER_GATE_INTEGRITY_RECOVERY, checkGraphOptionalIncludeViolations, evaluateConsumerGateIntegrity, formatConsumerGateIntegrityFailure, gateLocalName, gateNamespace, includeTaskfileRel, parseTaskfileIncludes, requiredNamespacesForGates, taskDefinedInTaskfileYaml, } from "./consumer-gate-integrity.js";
 export { CONSUMER_CHECK_GATES, checkGateId, checkGateSpawnArgs, FRAMEWORK_CHECK_GATES, gatesForCheckTarget, } from "./gate-lists.js";
 export { dispatchTaskCheck, isFrameworkRepoRoot, isFrameworkSourceContext, resolveCheckTarget, } from "./orchestrator.js";
 export { detectTestRunner, runnerDetectionTable, } from "./runner-detect.js";

package/dist/check/orchestrator.js

@@ -14,6 +14,7 @@
 import { spawnSync } from "node:child_process";
 import { join, resolve } from "node:path";
 import { dispatchCachedTaskCheck } from "./cached-orchestrator.js";
+import { evaluateConsumerGateIntegrity, formatConsumerGateIntegrityFailure, } from "./consumer-gate-integrity.js";
 import { resolveCheckTarget } from "./context.js";
 export { isFrameworkRepoRoot, isFrameworkSourceContext, resolveCheckTarget } from "./context.js";
 /**
@@ -35,6 +36,15 @@ export function dispatchTaskCheck(frameworkRoot, projectRoot, seams = {}) {
     const taskBin = seams.taskBin ?? "task";
     const target = resolveCheckTarget(resolvedFramework, resolvedProject);
     const cwd = target === "check:framework-source" ? resolvedFramework : resolvedProject;
+    // #3070: pre-flight consumer check-graph integrity (same path as cached
+    // orchestrator) so uncached aggregate shelling also fails with recovery text.
+    if (target === "check:consumer") {
+        const integrity = evaluateConsumerGateIntegrity(resolvedFramework);
+        if (!integrity.ok) {
+            process.stderr.write(formatConsumerGateIntegrityFailure(integrity));
+            return 2;
+        }
+    }
     const spawn = seams.spawnFn ?? defaultSpawn;
     const result = spawn(taskBin, [target, "--taskfile", taskfilePath], {
         cwd,

package/dist/content-contracts/skills/greptile-detector.d.ts

@@ -34,6 +34,13 @@ export declare const BODY_AC4_INLINE_SHA_CLEAN: string;
 export declare const BODY_AC4_THIRD_CONFIDENCE_FORM: string;
 export declare const BODY_AC4_EMPTY = "";
 export declare const BODY_AC4_TRUNCATED: string;
+/**
+ * Fail-closed CLEAN gate shared by pr:watch, swarm poller, and content-contracts.
+ *
+ * `minConfidence` defaults to the consumer bar (4 == legacy confidence > 3).
+ * Directive dogfood and project policy resolve a higher floor via
+ * `resolveMinGreptileConfidence` (#3095).
+ */
 export declare function evaluateCleanGate(params: {
     lastReviewedSha: string | null;
     headSha: string;
@@ -42,6 +49,8 @@ export declare function evaluateCleanGate(params: {
     ciFailures: number;
     errored: boolean;
     terminalCheckRun?: boolean;
+    /** Minimum confidence score (1–5) that CLEANs; score must be >= min. Default 4. */
+    minConfidence?: number;
 }): [boolean, string | null];
 type PollExitClass = "CLEAN" | "NEW_P0P1" | "ERRORED" | "STALL" | "RUNNING";
 export declare function simulatePollLoop(params: {

package/dist/content-contracts/skills/greptile-detector.js

@@ -277,15 +277,22 @@ export const BODY_AC4_THIRD_CONFIDENCE_FORM = "Greptile review of head 1234567\n
     `Last reviewed commit: [fix: foo](https://github.com/deftai/directive/commit/${HEAD_SHA})\n`;
 export const BODY_AC4_EMPTY = "";
 export const BODY_AC4_TRUNCATED = "Greptile review of head 1234567\n" + "\n" + "## Confidence Score:";
+/**
+ * Fail-closed CLEAN gate shared by pr:watch, swarm poller, and content-contracts.
+ *
+ * `minConfidence` defaults to the consumer bar (4 == legacy confidence > 3).
+ * Directive dogfood and project policy resolve a higher floor via
+ * `resolveMinGreptileConfidence` (#3095).
+ */
 export function evaluateCleanGate(params) {
-    const { lastReviewedSha, headSha, hasBlocking, confidence, ciFailures, errored, terminalCheckRun = true, } = params;
+    const { lastReviewedSha, headSha, hasBlocking, confidence, ciFailures, errored, terminalCheckRun = true, minConfidence = 4, } = params;
     if (lastReviewedSha === null || lastReviewedSha !== headSha) {
         return [false, "sha_match"];
     }
     if (hasBlocking) {
         return [false, "has_blocking"];
     }
-    if (confidence === null || confidence <= 3) {
+    if (confidence === null || confidence < minConfidence) {
         return [false, "confidence"];
     }
     if (ciFailures > 0) {

package/dist/doctor/index.d.ts

@@ -7,6 +7,7 @@ export * from "./json.js";
 export * from "./main.js";
 export * from "./manifest.js";
 export * from "./npm-registry.js";
+export * from "./openclaw-l2-adapter.js";
 export * from "./openclaw-skills.js";
 export * from "./paths.js";
 export * from "./payload-staleness.js";

package/dist/doctor/index.js

@@ -7,6 +7,7 @@ export * from "./json.js";
 export * from "./main.js";
 export * from "./manifest.js";
 export * from "./npm-registry.js";
+export * from "./openclaw-l2-adapter.js";
 export * from "./openclaw-skills.js";
 export * from "./paths.js";
 export * from "./payload-staleness.js";

package/dist/doctor/main.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { VBRIEF_VERSION } from "@deftai/directive-types";
 import { evaluate as evaluateAgentsMdAdvisory } from "../agents-md-advisory/evaluate.js";
+import { evaluateConsumerGateIntegrity, formatConsumerGateIntegrityFailure, } from "../check/consumer-gate-integrity.js";
 import { contentRoot } from "../content-root.js";
 import { resolveProjectDefinitionPath } from "../layout/resolve.js";
 import { DEFT_DIRECTIVE_DISABLE_FLAG_NAME, DEFT_DIRECTIVE_DISABLE_STATUS, DEFT_DIRECTIVE_DISABLE_TRACKED_WARNING, detectDeftDirectiveDisable, formatDeftDirectiveDisableMessage, isDeftDirectiveDisableActive, } from "../policy/deft-directive-disable.js";
@@ -22,6 +23,7 @@ import { formatAllowedFlagsHint, formatUnknownFlagsError, parseDoctorFlags } fro
 import { pythonJsonDump } from "./json.js";
 import { parseInstallRootFromAgentsMd } from "./manifest.js";
 import { runNpmRegistryMirrorCheck } from "./npm-registry.js";
+import { runOpenClawL2AdapterCheck } from "./openclaw-l2-adapter.js";
 import { runOpenClawSkillPinsCheck } from "./openclaw-skills.js";
 import { createPlainSink } from "./output.js";
 import { readTextSafe, resolveFrameworkRootForProject, resolvePath, resolveVersion, runningInsideDeftRepo, } from "./paths.js";
@@ -388,6 +390,11 @@ export function cmdDoctor(args, seams = {}) {
     if (!jsonMode) {
         sink.blank();
     }
+    sink.info("Checking consumer check-graph integrity (verify:orphan-active and peers)...");
+    runConsumerCheckGraphIntegrity(projectRoot, frameworkRoot, sink, addFinding, seams);
+    if (!jsonMode) {
+        sink.blank();
+    }
     sink.info("Checking OpenClaw always-pin skills...");
     runOpenClawSkillPinsCheck(sink, addFinding, {
         frameworkRoot,
@@ -409,6 +416,17 @@ export function cmdDoctor(args, seams = {}) {
     if (!jsonMode) {
         sink.blank();
     }
+    sink.info("Checking OpenClaw L2 product-command skills...");
+    runOpenClawL2AdapterCheck(sink, addFinding, {
+        projectRoot,
+        fixMode,
+        jsonMode,
+        allAgents: flags.openclawAllAgents,
+        seams,
+    });
+    if (!jsonMode) {
+        sink.blank();
+    }
     sink.info("Checking xBRIEF project envelope version...");
     runXbriefEnvelopeVersionCheck(projectRoot, sink, addFinding, seams);
     let resolution = null;
@@ -751,6 +769,57 @@ function runAgentsMdAdvisoryCheck(projectRoot, sink, addFinding, seams) {
         addFinding({ severity: "warning", message, check: checkName });
     }
 }
+/**
+ * Consumer check-graph integrity (#3070): every CONSUMER_CHECK_GATES entry
+ * (including `verify:orphan-active`) must resolve against the deposited
+ * Taskfile includes. Missing `tasks/verify.yml` previously failed only at
+ * go-task shell time with opaque exit 200/201.
+ */
+function runConsumerCheckGraphIntegrity(projectRoot, frameworkRoot, sink, addFinding, seams) {
+    const checkName = "consumer-check-graph-integrity";
+    if (runningInsideDeftRepo(projectRoot, seams)) {
+        // Still prove the source checkout ships a resolvable consumer gate set.
+        const integrity = evaluateConsumerGateIntegrity(frameworkRoot);
+        if (integrity.ok) {
+            sink.success(`${checkName}: source checkout resolves CONSUMER_CHECK_GATES (incl. verify:orphan-active)`);
+            return;
+        }
+        const message = formatConsumerGateIntegrityFailure(integrity).trim();
+        sink.error(message);
+        addFinding({
+            severity: "error",
+            message,
+            check: checkName,
+            suggestion: "deft update",
+            status: "fail",
+        });
+        return;
+    }
+    try {
+        const depositRoot = frameworkRoot;
+        const integrity = evaluateConsumerGateIntegrity(depositRoot);
+        if (integrity.ok) {
+            sink.success(`${checkName}: deposit resolves CONSUMER_CHECK_GATES (incl. verify:orphan-active)`);
+            return;
+        }
+        // Incomplete deposit is an error for consumers — check:consumer would hard-fail.
+        const message = formatConsumerGateIntegrityFailure(integrity).trim();
+        sink.error(message);
+        addFinding({
+            severity: "error",
+            message,
+            check: checkName,
+            suggestion: integrity.recovery,
+            status: "fail",
+            findings: integrity.findings,
+        });
+    }
+    catch (exc) {
+        const message = `${checkName}: probe failed -- ${exc instanceof Error ? exc.name : "Error"}: ${exc}`;
+        sink.warn(message);
+        addFinding({ severity: "warning", message, check: checkName });
+    }
+}
 function runTaskfileIncludeCheck(projectRoot, fixMode, jsonMode, sink, addFinding, seams) {
     if (runningInsideDeftRepo(projectRoot, seams)) {
         sink.info("Skipping Taskfile include check -- running inside the deft framework repo (the repo's own Taskfile.yml is the surface).");

package/dist/doctor/openclaw-l2-adapter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Doctor check + --fix wire for OpenClaw L2 product-command skills (#3064 D5).
+ *
+ * Primary operator recovery path when OpenClaw is detected. Deposits thin
+ * user-invocable router + 13 product skills into workspace skills roots.
+ * Fail-closed when OC signals are absent. Policy opt-out:
+ * `plan.policy.openClawProductCommands: false`.
+ */
+import { type OpenClawL2DepositResult } from "../slash/openclaw-deposit.js";
+import type { OutputSink } from "./output.js";
+import type { DoctorSeams, Finding } from "./types.js";
+/** Stable doctor check id for JSON findings. */
+export declare const OPENCLAW_L2_ADAPTER_CHECK = "openclaw-l2-product-commands";
+export interface RunOpenClawL2AdapterOptions {
+    readonly projectRoot: string;
+    readonly fixMode: boolean;
+    readonly jsonMode: boolean;
+    readonly allAgents: boolean;
+    readonly seams?: DoctorSeams;
+}
+/**
+ * Doctor check: OpenClaw L2 product-command skills present and current.
+ * No-ops when OpenClaw is not detected. Fix mode deposits managed skills.
+ */
+export declare function runOpenClawL2AdapterCheck(sink: OutputSink, addFinding: (finding: Finding) => void, options: RunOpenClawL2AdapterOptions): OpenClawL2DepositResult | null;
+//# sourceMappingURL=openclaw-l2-adapter.d.ts.map