@agentbridge1/cli 0.0.7 → 0.0.9

package/dist/contract-verdict.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOutOfScopeFiles = detectOutOfScopeFiles;
+exports.renderContractVerdict = renderContractVerdict;
+const domain_resolution_1 = require("./domain-resolution");
+const contract_intelligence_1 = require("./contract-intelligence");
+const diff_reader_1 = require("./diff-reader");
+const local_proof_1 = require("./local-proof");
+const INTENT_STOP_WORDS = new Set([
+    "a",
+    "an",
+    "the",
+    "on",
+    "in",
+    "to",
+    "for",
+    "and",
+    "or",
+    "of",
+    "fix",
+    "add",
+    "update",
+    "change",
+    "make",
+    "with",
+    "from",
+    "into",
+    "by",
+    "at",
+    "is",
+    "are",
+    "be",
+    "do",
+    "does",
+    "did",
+    "was",
+    "were",
+    "it",
+    "its",
+    "this",
+    "that",
+    "endpoint",
+    "bug",
+    "issue",
+    "error",
+]);
+function normalizePath(path) {
+    return path.trim().replaceAll("\\", "/");
+}
+function intentKeywords(intent) {
+    return intent
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .map((word) => word.trim())
+        .filter((word) => word.length >= 3 && !INTENT_STOP_WORDS.has(word));
+}
+function fileMatchesIntentKeywords(file, keywords) {
+    if (keywords.length === 0)
+        return true;
+    const lower = normalizePath(file).toLowerCase();
+    return keywords.some((keyword) => lower.includes(keyword));
+}
+function fileMatchesClaimedPaths(file, claimedPaths) {
+    if (claimedPaths.length === 0)
+        return true;
+    const normalized = normalizePath(file);
+    return claimedPaths.some((pattern) => {
+        const trimmed = normalizePath(pattern);
+        if (!trimmed)
+            return false;
+        if (trimmed.endsWith("/**")) {
+            const prefix = trimmed.slice(0, -3);
+            return normalized === prefix || normalized.startsWith(`${prefix}/`);
+        }
+        if (trimmed.endsWith("/*")) {
+            const prefix = trimmed.slice(0, -2);
+            const slash = normalized.lastIndexOf("/");
+            const dir = slash >= 0 ? normalized.slice(0, slash) : "";
+            return dir === prefix;
+        }
+        return normalized === trimmed || normalized.startsWith(`${trimmed}/`);
+    });
+}
+function detectOutOfScopeFiles(changedFiles, session, domains) {
+    const meaningful = changedFiles
+        .map(normalizePath)
+        .filter((file) => file.length > 0 && !(0, local_proof_1.isProofNoiseFile)(file));
+    if (meaningful.length === 0)
+        return [];
+    const claimedPaths = session?.claimedPaths ?? [];
+    if (claimedPaths.length > 0) {
+        return meaningful.filter((file) => !fileMatchesClaimedPaths(file, claimedPaths));
+    }
+    const intent = session?.intent?.trim() ?? "";
+    if (!intent)
+        return [];
+    const keywords = intentKeywords(intent);
+    if (keywords.length === 0)
+        return [];
+    const outOfScope = [];
+    for (const file of meaningful) {
+        if (fileMatchesIntentKeywords(file, keywords))
+            continue;
+        if (domains.length > 0) {
+            const domain = (0, domain_resolution_1.resolveDomainForFile)(file, domains).domain;
+            if (domain && keywords.some((keyword) => domain.toLowerCase().includes(keyword))) {
+                continue;
+            }
+        }
+        outOfScope.push(file);
+    }
+    return outOfScope;
+}
+function renderContractVerdict(session, changedFiles, proofRun, domains = []) {
+    const intent = session?.intent?.trim() || "(no intent declared)";
+    const meaningfulFiles = changedFiles
+        .map(normalizePath)
+        .filter((file) => file.length > 0 && !(0, local_proof_1.isProofNoiseFile)(file));
+    const outOfScope = detectOutOfScopeFiles(meaningfulFiles, session, domains);
+    const contract = session?.intent?.trim()
+        ? (0, contract_intelligence_1.localSessionToContractIntelligence)(session)
+        : null;
+    // Read diff once — fresh from git, not stored in session
+    const diff = meaningfulFiles.length > 0 ? (0, diff_reader_1.readRepoDiff)(meaningfulFiles) : null;
+    // Evaluate criteria if we have a session with intent
+    const criteriaEvals = contract
+        ? (0, contract_intelligence_1.evaluateCompletionCriteria)({
+            contract,
+            changedFiles: meaningfulFiles,
+            proofRun,
+            diff,
+        })
+        : null;
+    const proofNeeded = contract?.proofNeeded ?? [];
+    const evidenced = criteriaEvals?.filter((e) => e.status === "evidence_found") ?? [];
+    // Next step: criteria-driven if available, else generic
+    let nextStep;
+    if (criteriaEvals && criteriaEvals.length > 0) {
+        nextStep = (0, contract_intelligence_1.nextStepFromCriteria)(criteriaEvals, proofNeeded);
+    }
+    else if (!proofRun) {
+        nextStep = "Run the relevant test command so AgentBridge can record proof for this contract.";
+    }
+    else if (outOfScope.length > 0) {
+        nextStep = "Ask the agent to justify the out-of-scope files, or revert them before accepting the work.";
+    }
+    else if (meaningfulFiles.length === 0) {
+        nextStep = "No work was recorded. Start a new contract when you are ready to implement.";
+    }
+    else {
+        nextStep = "Contract looks complete. Commit when ready.";
+    }
+    const lines = [
+        "AgentBridge Contract Verdict",
+        "─────────────────────────────────────────",
+        "",
+        "Here's what the contract was:",
+        `  ${intent}`,
+        "",
+        "Here's what the agent changed:",
+    ];
+    if (meaningfulFiles.length === 0) {
+        lines.push("  No files changed.");
+    }
+    else {
+        for (const file of meaningfulFiles) {
+            lines.push(`  - ${file}`);
+        }
+    }
+    if (criteriaEvals && criteriaEvals.length > 0) {
+        lines.push("", "Here's what \"done\" needed to prove:");
+        for (const e of criteriaEvals) {
+            const icon = e.status === "evidence_found"
+                ? "✓"
+                : e.status === "partial_evidence"
+                    ? "~"
+                    : e.status === "cannot_verify"
+                        ? "?"
+                        : "✗";
+            lines.push(`  ${icon} [${e.status}] ${e.criterion}`);
+            lines.push(`      ${e.evidence}`);
+        }
+    }
+    else {
+        lines.push("", "Here's what appears missing:");
+        const missing = [];
+        if (!session?.intent?.trim())
+            missing.push("No contract intent was recorded.");
+        if (meaningfulFiles.length === 0)
+            missing.push("No files changed since the contract baseline.");
+        if (!proofRun)
+            missing.push("No proof/test run was recorded.");
+        else if (proofRun.status === "failed")
+            missing.push(`Proof failed: ${proofRun.command} (exit ${proofRun.exitCode}).`);
+        if (missing.length === 0) {
+            lines.push("  Nothing obvious from this contract check.");
+        }
+        else {
+            for (const item of missing)
+                lines.push(`  - ${item}`);
+        }
+    }
+    if (evidenced.length > 0 && criteriaEvals) {
+        lines.push("", "Here's what AgentBridge saw evidence for:");
+        for (const e of evidenced) {
+            lines.push(`  - ${e.criterion}`);
+        }
+    }
+    const stillUnproven = criteriaEvals
+        ? criteriaEvals.filter((e) => e.status === "no_evidence")
+        : [];
+    lines.push("", "Here's what is still unproven:");
+    if (stillUnproven.length === 0 && (!criteriaEvals || criteriaEvals.length === 0)) {
+        lines.push(!proofRun ? "  No proof/test run was recorded." : "  Nothing obvious from this contract check.");
+    }
+    else if (stillUnproven.length === 0) {
+        lines.push("  Nothing detected as fully unproven.");
+    }
+    else {
+        for (const e of stillUnproven) {
+            lines.push(`  - ${e.criterion}`);
+            lines.push(`    ${e.evidence}`);
+        }
+    }
+    lines.push("", "Here's where the work drifted out of scope:");
+    if (outOfScope.length === 0) {
+        lines.push("  No out-of-scope files detected.");
+    }
+    else {
+        for (const file of outOfScope) {
+            const reason = session?.intent?.trim()
+                ? `${file} was changed, but the contract was about ${session.intent.trim()}.`
+                : `${file} was changed outside the declared contract.`;
+            lines.push(`  - ${reason}`);
+        }
+    }
+    lines.push("", "Here's the next step:", `  ${nextStep}`, "");
+    return lines.join("\n");
+}

package/dist/diff-reader.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Diff reader — parses `git diff HEAD` output into structured change data.
+ * All logic is deterministic regex on git unified diff format. No LLM.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRepoDiff = readRepoDiff;
+exports.parseDiffString = parseDiffString;
+exports.getDiffForFile = getDiffForFile;
+exports.summariseDiff = summariseDiff;
+const node_child_process_1 = require("node:child_process");
+// Function declarations
+const FN_ADDED_RE = /^\+\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/;
+const FN_REMOVED_RE = /^-\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/;
+// Arrow / const functions: `const foo = (` or `const foo = async (`
+const ARROW_ADDED_RE = /^\+\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/;
+const ARROW_REMOVED_RE = /^-\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/;
+// Non-function consts: `const FOO_BAR =` (all-caps or mixed without open paren)
+const CONST_ADDED_RE = /^\+\s*(?:export\s+)?const\s+(\w+)\s*=/;
+const CONST_REMOVED_RE = /^-\s*(?:export\s+)?const\s+(\w+)\s*=/;
+// Import lines
+const IMPORT_ADDED_RE = /^\+\s*import\s+.+\s+from\s+['"]([^'"]+)['"]/;
+const IMPORT_REMOVED_RE = /^-\s*import\s+.+\s+from\s+['"]([^'"]+)['"]/;
+// Named exports (excluding consts/functions already captured)
+const EXPORT_ADDED_RE = /^\+\s*export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/;
+const EXPORT_REMOVED_RE = /^-\s*export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/;
+// Guard clauses: if(!x) throw / return / continue / break
+const GUARD_RE = /^\+.*\bif\s*\([^)]*\).*\b(?:throw|return new Error|return null|return undefined)\b/;
+// File header in git diff: "diff --git a/foo b/foo"
+const FILE_HEADER_RE = /^diff --git a\/(.+) b\/.+/;
+// Hunk header: @@ -a,b +c,d @@
+const HUNK_RE = /^@@/;
+function isArrowOrFnConst(line, added) {
+    const re = added ? ARROW_ADDED_RE : ARROW_REMOVED_RE;
+    return re.exec(line)?.[1] ?? null;
+}
+function isRegularConst(line, added) {
+    // Only count if it's NOT an arrow function (no open paren immediately after =)
+    const arrowRe = added ? ARROW_ADDED_RE : ARROW_REMOVED_RE;
+    if (arrowRe.test(line))
+        return null;
+    const re = added ? CONST_ADDED_RE : CONST_REMOVED_RE;
+    return re.exec(line)?.[1] ?? null;
+}
+function parseFileDiff(fileName, diffLines) {
+    const fd = {
+        file: fileName,
+        functions_added: [],
+        functions_removed: [],
+        functions_changed: [],
+        constants_added: [],
+        constants_removed: [],
+        imports_added: [],
+        imports_removed: [],
+        exports_added: [],
+        exports_removed: [],
+        guard_clauses_added: 0,
+        lines_added: 0,
+        lines_removed: 0,
+    };
+    for (const line of diffLines) {
+        if (HUNK_RE.test(line))
+            continue;
+        const isAdd = line.startsWith("+") && !line.startsWith("+++");
+        const isDel = line.startsWith("-") && !line.startsWith("---");
+        if (isAdd)
+            fd.lines_added++;
+        if (isDel)
+            fd.lines_removed++;
+        // Functions
+        const fnAdded = FN_ADDED_RE.exec(line)?.[1] ?? isArrowOrFnConst(line, true);
+        if (fnAdded) {
+            if (fd.functions_removed.includes(fnAdded)) {
+                fd.functions_changed.push(fnAdded);
+                fd.functions_removed.splice(fd.functions_removed.indexOf(fnAdded), 1);
+            }
+            else {
+                fd.functions_added.push(fnAdded);
+            }
+        }
+        const fnRemoved = FN_REMOVED_RE.exec(line)?.[1] ?? isArrowOrFnConst(line, false);
+        if (fnRemoved) {
+            const addedIdx = fd.functions_added.indexOf(fnRemoved);
+            if (addedIdx >= 0) {
+                fd.functions_changed.push(fnRemoved);
+                fd.functions_added.splice(addedIdx, 1);
+            }
+            else {
+                fd.functions_removed.push(fnRemoved);
+            }
+        }
+        // Constants (non-function)
+        const constAdded = isRegularConst(line, true);
+        if (constAdded)
+            fd.constants_added.push(constAdded);
+        const constRemoved = isRegularConst(line, false);
+        if (constRemoved)
+            fd.constants_removed.push(constRemoved);
+        // Imports
+        const importAdded = IMPORT_ADDED_RE.exec(line)?.[1];
+        if (importAdded)
+            fd.imports_added.push(importAdded);
+        const importRemoved = IMPORT_REMOVED_RE.exec(line)?.[1];
+        if (importRemoved)
+            fd.imports_removed.push(importRemoved);
+        // Exports
+        const exportAdded = EXPORT_ADDED_RE.exec(line)?.[1];
+        if (exportAdded && !fd.functions_added.includes(exportAdded) && !fd.constants_added.includes(exportAdded)) {
+            fd.exports_added.push(exportAdded);
+        }
+        const exportRemoved = EXPORT_REMOVED_RE.exec(line)?.[1];
+        if (exportRemoved && !fd.functions_removed.includes(exportRemoved) && !fd.constants_removed.includes(exportRemoved)) {
+            fd.exports_removed.push(exportRemoved);
+        }
+        // Guard clauses
+        if (isAdd && GUARD_RE.test(line))
+            fd.guard_clauses_added++;
+    }
+    return fd;
+}
+/**
+ * Reads git diff HEAD for the given changed files and returns structured diffs.
+ * Falls back gracefully if git is unavailable or diff fails.
+ */
+function readRepoDiff(changedFiles) {
+    if (changedFiles.length === 0)
+        return { files: [], totalLinesAdded: 0, totalLinesRemoved: 0 };
+    let rawDiff;
+    try {
+        rawDiff = (0, node_child_process_1.execFileSync)("git", ["diff", "HEAD", "--unified=0", "--", ...changedFiles], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 5000,
+        });
+    }
+    catch {
+        // Fallback: try diff against staged + unstaged
+        try {
+            rawDiff = (0, node_child_process_1.execFileSync)("git", ["diff", "--unified=0", "--", ...changedFiles], {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 5000,
+            });
+        }
+        catch {
+            return { files: [], totalLinesAdded: 0, totalLinesRemoved: 0 };
+        }
+    }
+    return parseDiffString(rawDiff);
+}
+/**
+ * Parse a raw git diff string into RepoDiff. Exported for testing without git.
+ */
+function parseDiffString(rawDiff) {
+    const lines = rawDiff.split("\n");
+    const fileBlocks = [];
+    let current = null;
+    for (const line of lines) {
+        const fileMatch = FILE_HEADER_RE.exec(line);
+        if (fileMatch) {
+            if (current)
+                fileBlocks.push(current);
+            current = { name: fileMatch[1], lines: [] };
+        }
+        else if (current) {
+            current.lines.push(line);
+        }
+    }
+    if (current)
+        fileBlocks.push(current);
+    const files = fileBlocks.map((b) => parseFileDiff(b.name, b.lines));
+    return {
+        files,
+        totalLinesAdded: files.reduce((s, f) => s + f.lines_added, 0),
+        totalLinesRemoved: files.reduce((s, f) => s + f.lines_removed, 0),
+    };
+}
+/**
+ * Returns a FileDiff for a specific file, or null if not in the diff.
+ */
+function getDiffForFile(diff, file) {
+    const normalized = file.replaceAll("\\", "/");
+    return diff.files.find((f) => f.file === normalized || f.file.endsWith(`/${normalized}`) || normalized.endsWith(`/${f.file}`)) ?? null;
+}
+/**
+ * Summarise diff changes across all files in a few readable tokens for evidence strings.
+ */
+function summariseDiff(diff) {
+    const allExportsAdded = diff.files.flatMap((f) => f.exports_added.concat(f.functions_added));
+    const allGuards = diff.files.reduce((s, f) => s + f.guard_clauses_added, 0);
+    const parts = [];
+    if (diff.totalLinesAdded > 0 || diff.totalLinesRemoved > 0) {
+        parts.push(`+${diff.totalLinesAdded}/-${diff.totalLinesRemoved} lines`);
+    }
+    if (allExportsAdded.length > 0)
+        parts.push(`${allExportsAdded.length} new export(s): ${allExportsAdded.slice(0, 3).join(", ")}`);
+    if (allGuards > 0)
+        parts.push(`${allGuards} guard clause(s) added`);
+    return parts.join("; ");
+}

package/dist/error-catalog.js

@@ -30,6 +30,19 @@ const CATALOG = {
         why: "Commands target the wrong room or environment.",
         next: "Verify AGENTBRIDGE_PROJECT_ID and rerun `agentbridge init --project <id>`.",
     },
+    CONNECT_EXECUTION_SURFACE_MISSING: {
+        code: "CONNECT_EXECUTION_SURFACE_MISSING",
+        category: "IDENTITY_ERROR",
+        title: "Connection incomplete.",
+        what: "Project access was verified, but this key is not bound to an AgentConnection execution surface.",
+        why: "Connect requires a room connection key that resolves to work_identity on /hello.",
+        next: [
+            "In the AgentBridge dashboard, open this room and rotate the API key (or create a new room).",
+            "Update AGENTBRIDGE_API_KEY or .agentbridge/config.json with the new key.",
+            "Run: agentbridge connect --project <project-id> --api-key <new-key>",
+            "Connect does not create or rotate keys automatically.",
+        ].join("\n"),
+    },
     IDENTITY_ACTIVE_AGENT_STALE: {
         code: "IDENTITY_ACTIVE_AGENT_STALE",
         category: "IDENTITY_ERROR",
@@ -229,6 +242,22 @@ const CATALOG = {
         why: "Scoped work must target a recovered domain lane.",
         next: 'Pass `--domain "<domain>"` with start, or run `agentbridge init`.',
     },
+    START_LANE_CLAIM_CONFIRM_REQUIRED: {
+        code: "START_LANE_CLAIM_CONFIRM_REQUIRED",
+        category: "START_ERROR",
+        title: "Lane claim needs explicit confirmation.",
+        what: "Start inferred a domain with medium confidence.",
+        why: "Production-safe lane claim requires explicit confirmation when scope-to-domain mapping is ambiguous.",
+        next: 'Rerun with `--confirm-domain` or pass an explicit `--domain "<domain>"`.',
+    },
+    START_LANE_CLAIM_LOW_CONFIDENCE: {
+        code: "START_LANE_CLAIM_LOW_CONFIDENCE",
+        category: "START_ERROR",
+        title: "Lane claim confidence too low.",
+        what: "AgentBridge could not confidently bind this work to a single domain lane.",
+        why: "A wrong lane claim undermines scope enforcement and ownership attribution.",
+        next: 'Pass explicit `--domain "<domain>"` and tighter `--scope "<path>"`, then rerun start.',
+    },
     START_OWNER_UNRESOLVED: {
         code: "START_OWNER_UNRESOLVED",
         category: "START_ERROR",

package/dist/git-status.js

@@ -7,6 +7,7 @@ exports.repoDirtySnapshotFromGitStatus = repoDirtySnapshotFromGitStatus;
 exports.getBranchName = getBranchName;
 exports.getDirtyWorkingTreeFiles = getDirtyWorkingTreeFiles;
 const node_child_process_1 = require("node:child_process");
+const local_proof_1 = require("./local-proof");
 function normalizePath(path) {
     return path.trim().replaceAll("\\", "/");
 }
@@ -41,13 +42,16 @@ function parseGitStatusPorcelainZ(raw) {
     }
     return entries;
 }
+function isSupervisionRelevantPath(path) {
+    return !isAgentbridgeLocalPath(path) && !(0, local_proof_1.isProofNoiseFile)(path);
+}
 function collectChangedFilesFromStatusEntries(entries) {
     const files = new Set();
     for (const entry of entries) {
-        if (entry.path && !isAgentbridgeLocalPath(entry.path)) {
+        if (entry.path && isSupervisionRelevantPath(entry.path)) {
             files.add(entry.path);
         }
-        if (entry.originalPath && !isAgentbridgeLocalPath(entry.originalPath)) {
+        if (entry.originalPath && isSupervisionRelevantPath(entry.originalPath)) {
             files.add(entry.originalPath);
         }
     }

package/dist/index.js

@@ -55,11 +55,11 @@ const COMMAND_HELP = {
         "    Run `agentbridge connect` first to save credentials.\n",
     use: "  agentbridge use <agent-id>\n" +
         "    Set the active agent identity used by `watch` and `start`.\n",
-    start: "  agentbridge start [\"intent\"] [--details] [--yes]\n" +
+    start: "  agentbridge start [\"intent\"] [--details] [--yes] [--confirm-domain]\n" +
         "    Open or close a task checkpoint (not the live watcher).\n" +
         "    For live supervision beside Cursor, run `agentbridge watch`.\n" +
         "    Record proof: `agentbridge verify -- <test command>`.\n",
-    watch: "  agentbridge watch [--allow-dirty] [--once] [--daemon] [--details] [--task \"<summary>\"] [--scope \"<path>\"]\n" +
+    watch: "  agentbridge watch [--allow-dirty] [--once] [--daemon] [--details] [--confirm-domain] [--task \"<summary>\"] [--scope \"<path>\"]\n" +
         "    Primary live supervision command — run beside Cursor while the agent codes.\n" +
         "    Shows MCP-declared intent and disk changes; warns on scope drift.\n" +
         "    No --task or --scope required for normal use.\n" +
@@ -68,8 +68,9 @@ const COMMAND_HELP = {
         "    --once            Run one supervision pass and exit.\n" +
         "    --daemon          Non-interactive mode: skip prompts, auto-deny domain crossings.\n" +
         "    --change-request / --execution-surface  Advanced session binding.\n",
-    "setup-mcp": "  agentbridge setup-mcp [--editor cursor|windsurf|vscode]\n" +
-        "    Print the MCP server configuration snippet to add to your editor.\n",
+    "setup-mcp": "  agentbridge setup-mcp [--local] [--editor cursor|windsurf|vscode]\n" +
+        "    --local           Write local-first MCP config (no API keys) to .cursor/mcp.json\n" +
+        "    Print or write the MCP server configuration for your editor.\n",
     mcp: "  agentbridge mcp\n" +
         "    Start the AgentBridge MCP stdio server.\n",
     status: "  agentbridge status [--repair] [--json]\n    Show current work session status.\n",
@@ -300,7 +301,10 @@ async function main() {
         return;
     }
     if (command === "setup-mcp") {
-        await (0, setup_mcp_1.runSetupMcp)({ editor: flags["--editor"] });
+        await (0, setup_mcp_1.runSetupMcp)({
+            editor: flags["--editor"],
+            local: flags["--local"] === "true",
+        });
         return;
     }
     if (command === "mcp") {
@@ -372,6 +376,7 @@ async function main() {
             daemon: flags["--daemon"] === "true",
             once: flags["--once"] === "true",
             details: flags["--details"] === "true",
+            confirmDomain: flags["--confirm-domain"] === "true",
         });
         return;
     }
@@ -391,6 +396,7 @@ async function main() {
             resume: flags["--resume"] === "true",
             details: flags["--details"] === "true",
             confirmClose: flags["--yes"] === "true",
+            confirmDomain: flags["--confirm-domain"] === "true",
         });
         return;
     }