@xnetjs/cli 0.0.2 → 0.0.4

package/dist/cli.js

@@ -8,9 +8,793 @@ import {
 // src/cli.ts
 import { program } from "commander";
 
+// src/commands/agent.ts
+import { readFile, rename, mkdir } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import {
+  ScriptSandbox,
+  XNET_AGENT_SKILL_MD,
+  createAgentScriptContext,
+  createAiSurfaceService,
+  createAiWorkspaceExporter,
+  createAiWorkspaceWatcher,
+  flattenRowForTsv,
+  toTsv
+} from "@xnetjs/plugins/node";
+
+// src/utils/agent-remote.ts
+var RemoteApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "RemoteApiError";
+  }
+};
+async function createRemoteAgentBackend(options = {}) {
+  const baseUrl = (options.apiUrl ?? process.env.XNET_API_URL ?? "http://127.0.0.1:31415").replace(
+    /\/$/,
+    ""
+  );
+  const token = options.token ?? process.env.XNET_API_TOKEN;
+  const request = async (method, path, body) => {
+    const response = await fetch(`${baseUrl}${path}`, {
+      method,
+      headers: {
+        "content-type": "application/json",
+        ...token ? { authorization: `Bearer ${token}` } : {}
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    const text2 = await response.text();
+    const parsed = text2 ? JSON.parse(text2) : null;
+    if (!response.ok) {
+      const message = isRecord(parsed) && typeof parsed.error === "string" ? parsed.error : `${method} ${path} failed with ${response.status}`;
+      throw new RemoteApiError(message, response.status);
+    }
+    return parsed;
+  };
+  const store = {
+    get: async (id) => {
+      try {
+        return await request("GET", `/api/v1/nodes/${encodeURIComponent(id)}`);
+      } catch (err) {
+        if (err instanceof RemoteApiError && err.status === 404) return null;
+        throw err;
+      }
+    },
+    list: async (listOptions) => {
+      const params = new URLSearchParams();
+      if (listOptions?.schemaId) params.set("schema", listOptions.schemaId);
+      if (listOptions?.limit !== void 0) params.set("limit", String(listOptions.limit));
+      if (listOptions?.offset !== void 0) params.set("offset", String(listOptions.offset));
+      const query = params.size > 0 ? `?${params.toString()}` : "";
+      const result = await request("GET", `/api/v1/nodes${query}`);
+      return isRecord(result) && Array.isArray(result.nodes) ? result.nodes : [];
+    },
+    create: async ({ schemaId, properties }) => await request("POST", "/api/v1/nodes", { schema: schemaId, properties }),
+    update: async (id, { properties }) => await request("PATCH", `/api/v1/nodes/${encodeURIComponent(id)}`, properties),
+    delete: async (id) => {
+      await request("DELETE", `/api/v1/nodes/${encodeURIComponent(id)}`);
+    },
+    subscribe: () => () => {
+    }
+  };
+  const schemaCache = /* @__PURE__ */ new Map();
+  const listed = await request("GET", "/api/v1/schemas");
+  if (isRecord(listed) && Array.isArray(listed.schemas)) {
+    for (const schema of listed.schemas) {
+      if (isRecord(schema) && typeof schema.iri === "string") {
+        schemaCache.set(schema.iri, schema);
+      }
+    }
+  }
+  const schemas = {
+    getAllIRIs: () => Array.from(schemaCache.keys()),
+    get: async (iri) => {
+      const cached = schemaCache.get(iri);
+      if (cached) return cached;
+      try {
+        const fetched = await request(
+          "GET",
+          `/api/v1/schemas/${encodeURIComponent(iri)}`
+        );
+        schemaCache.set(iri, fetched);
+        return fetched;
+      } catch (err) {
+        if (err instanceof RemoteApiError && err.status === 404) return null;
+        throw err;
+      }
+    }
+  };
+  return { store, schemas };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/commands/agent.ts
+function createAgentServices(backend) {
+  const aiSurface = createAiSurfaceService({ store: backend.store, schemas: backend.schemas });
+  return {
+    store: backend.store,
+    schemas: backend.schemas,
+    aiSurface,
+    exporter: createAiWorkspaceExporter({ ...backend, aiSurface }),
+    watcher: createAiWorkspaceWatcher({ ...backend, aiSurface })
+  };
+}
+var defaultServicesFactory = async ({ apiUrl }) => createAgentServices(await createRemoteAgentBackend({ apiUrl }));
+async function runCheckout(services, options) {
+  const result = await services.exporter.checkout({
+    rootDir: resolve(options.dir),
+    ...options.name ? { workspaceName: options.name } : {},
+    scope: {
+      ...options.query ? { query: options.query } : {},
+      ...options.schema?.length ? { schemaIds: options.schema } : {},
+      ...options.node?.length ? { nodeIds: options.node } : {},
+      ...options.kind?.length ? { kinds: options.kind } : {},
+      ...options.limit !== void 0 ? { limit: options.limit } : {}
+    }
+  });
+  const lines = result.manifestEntries.map((entry) => `${entry.path}	${entry.id}`);
+  return [
+    `checked out ${result.manifestEntries.length} file(s) into ${options.dir}`,
+    ...lines
+  ].join("\n");
+}
+async function runStatus(services, options) {
+  const scan = await services.watcher.scanChangedFiles({
+    rootDir: resolve(options.dir),
+    writePendingPlans: false,
+    writeConflicts: false,
+    writeReviewIndex: false
+  });
+  if (options.format === "json") {
+    return JSON.stringify({
+      pendingPlans: scan.pendingPlans.map((pending) => ({
+        path: pending.path,
+        planId: pending.plan.id,
+        intent: pending.plan.intent
+      })),
+      conflicts: scan.conflicts
+    });
+  }
+  const lines = [
+    ...scan.pendingPlans.map(
+      (pending) => `pending	${pending.path}	${pending.plan.id}	${pending.plan.intent}`
+    ),
+    ...scan.conflicts.map(
+      (conflict) => `conflict	${conflict.path}	${conflict.kind}	${conflict.message}`
+    )
+  ];
+  return lines.length > 0 ? lines.join("\n") : "clean";
+}
+async function runCommit(services, options) {
+  const rootDir = resolve(options.dir);
+  const scan = await services.watcher.scanChangedFiles({
+    rootDir,
+    actor: options.actor ?? "xnet-cli"
+  });
+  const lines = [];
+  for (const conflict of scan.conflicts) {
+    lines.push(`conflict	${conflict.path}	${conflict.kind}	see ${conflict.notePath ?? ""}`);
+  }
+  if (!options.apply) {
+    for (const pending of scan.pendingPlans) {
+      lines.push(`planned	${pending.path}	${pending.plan.id}`);
+    }
+    if (scan.pendingPlans.length === 0 && scan.conflicts.length === 0) return "clean";
+    lines.push(`${scan.pendingPlans.length} plan(s) pending; re-run with --apply to apply`);
+    return lines.join("\n");
+  }
+  const appliedNodeIds = [];
+  for (const pending of scan.pendingPlans) {
+    const outcome = await applyPendingPlan(services, pending.plan);
+    lines.push(`${outcome.status}	${pending.path}	${pending.plan.id}	${outcome.detail}`);
+    if (outcome.status === "applied") {
+      appliedNodeIds.push(...pending.plan.changes.map((change) => change.targetId));
+      await archivePendingPlan(rootDir, pending.planPath);
+    }
+  }
+  if (appliedNodeIds.length > 0) {
+    await services.exporter.checkout({ rootDir, scope: { nodeIds: appliedNodeIds } });
+  }
+  return lines.length > 0 ? lines.join("\n") : "clean";
+}
+var APPLY_TOOL_BY_TARGET_KIND = {
+  page: "xnet_apply_page_markdown",
+  database: "xnet_apply_database_mutation",
+  databaseRows: "xnet_apply_database_mutation"
+};
+async function applyPendingPlan(services, plan) {
+  const targetKind = plan.changes[0]?.targetKind ?? "unknown";
+  const tool = APPLY_TOOL_BY_TARGET_KIND[targetKind];
+  if (!tool) {
+    return { status: "skipped", detail: `${targetKind} plans need review in the xNet app` };
+  }
+  try {
+    const result = await services.aiSurface.callTool(tool, { plan, confirmApply: true });
+    return result.applied ? { status: "applied", detail: `${targetKind} plan applied` } : { status: "failed", detail: result.validation?.errors?.join("; ") ?? "not applied" };
+  } catch (err) {
+    return { status: "failed", detail: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function archivePendingPlan(rootDir, planPath) {
+  const appliedPath = planPath.replace(".xnet/pending/", ".xnet/applied/");
+  try {
+    await mkdir(dirname(join(rootDir, appliedPath)), { recursive: true });
+    await rename(join(rootDir, planPath), join(rootDir, appliedPath));
+  } catch {
+  }
+}
+async function runSearch(services, options) {
+  const result = await services.aiSurface.search({
+    query: options.text,
+    schemaId: options.schema,
+    limit: options.limit
+  });
+  const results = Array.isArray(result.results) ? result.results : [];
+  if (options.format === "json") return JSON.stringify(result);
+  if (options.format === "jsonl") return results.map((row) => JSON.stringify(row)).join("\n");
+  const compact = results.map((row) => ({
+    id: row.id,
+    schemaId: row.schemaId,
+    title: row.title,
+    snippet: row.snippet
+  }));
+  if (results.length === 0) return "no results";
+  if (options.format === "md") return toMarkdownTable(compact);
+  return toTsv(compact).trimEnd();
+}
+async function runQuery(services, options) {
+  const where = parseAssignments(options.where ?? []);
+  const result = await services.aiSurface.callTool("xnet_database_query", {
+    databaseId: options.databaseId,
+    ...Object.keys(where).length > 0 ? { where } : {},
+    ...options.limit !== void 0 ? { limit: options.limit } : {},
+    ...options.offset !== void 0 ? { offset: options.offset } : {}
+  });
+  const rows = Array.isArray(result.rows) ? result.rows : [];
+  if (options.format === "json") {
+    return JSON.stringify(
+      options.detailed ? result : {
+        databaseId: result.databaseId,
+        count: result.count,
+        totalCount: result.totalCount,
+        rows
+      }
+    );
+  }
+  if (options.format === "jsonl") return rows.map((row) => JSON.stringify(row)).join("\n");
+  if (rows.length === 0) return "no rows";
+  if (options.format === "md") {
+    return toMarkdownTable(rows.map((row) => flattenRowForTsv(row)));
+  }
+  return toTsv(rows).trimEnd();
+}
+function toMarkdownTable(rows) {
+  const columns = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!columns.includes(key)) columns.push(key);
+    }
+  }
+  const cell = (value) => {
+    if (value === null || value === void 0) return "";
+    const text2 = typeof value === "object" ? JSON.stringify(value) : String(value);
+    return text2.replace(/[|\n\r\t]+/g, " ");
+  };
+  return [
+    `| ${columns.join(" | ")} |`,
+    `| ${columns.map(() => "---").join(" | ")} |`,
+    ...rows.map((row) => `| ${columns.map((column) => cell(row[column])).join(" | ")} |`)
+  ].join("\n");
+}
+async function runDbGet(services, options) {
+  const node = await services.store.get(options.nodeId);
+  if (!node) throw new Error(`Node not found: ${options.nodeId}`);
+  if (options.detailed) return JSON.stringify(node);
+  return JSON.stringify({
+    id: node.id,
+    schemaId: node.schemaId,
+    properties: node.properties,
+    revision: `updatedAt:${node.updatedAt}`
+  });
+}
+async function runDbSet(services, options) {
+  const properties = parseAssignments(options.assignments);
+  if (Object.keys(properties).length === 0) {
+    throw new Error("db set requires at least one field=value assignment");
+  }
+  const plan = await services.aiSurface.callTool("xnet_plan_database_mutation", {
+    databaseId: options.databaseId,
+    actor: options.actor ?? "xnet-cli",
+    intent: `Update row ${options.rowId} via xnet db set`,
+    operations: [{ op: "updateRow", args: { rowId: options.rowId, properties } }]
+  });
+  if (!plan.validation.valid) {
+    throw new Error(`plan invalid: ${plan.validation.errors.join("; ")}`);
+  }
+  if (options.planOnly) return JSON.stringify(plan);
+  const result = await services.aiSurface.callTool("xnet_apply_database_mutation", {
+    plan,
+    confirmApply: true
+  });
+  if (!result.applied) {
+    throw new Error(`apply failed: ${result.validation?.errors?.join("; ") ?? "unknown error"}`);
+  }
+  return `applied	${options.rowId}	${plan.id}`;
+}
+async function runScript(services, options) {
+  const code = await readFile(resolve(options.file), "utf8");
+  const nodes = await services.store.list({
+    ...options.schema ? { schemaId: options.schema } : {},
+    limit: options.limit ?? 200,
+    offset: 0
+  });
+  const flatNodes = nodes.filter((node) => !node.deleted).map(toFlatNode);
+  const currentNode = options.node ? flatNodes.find((node) => node.id === options.node) : void 0;
+  const session = createAgentScriptContext({
+    nodes: flatNodes,
+    ...currentNode ? { node: currentNode } : {}
+  });
+  const sandbox = new ScriptSandbox({ timeoutMs: options.timeoutMs ?? 5e3 });
+  const result = await sandbox.execute(code, session.context);
+  const plan = session.toMutationPlan({ actor: options.actor ?? "xnet-cli-script" });
+  const output = { result };
+  if (plan) {
+    output.plan = { id: plan.id, changes: plan.changes.length, valid: plan.validation.valid };
+    if (options.dir) {
+      const planPath = `.xnet/pending/${plan.id}.plan.json`;
+      const fullPath = join(resolve(options.dir), planPath);
+      await mkdir(dirname(fullPath), { recursive: true });
+      await (await import("fs/promises")).writeFile(fullPath, `${JSON.stringify(plan, null, 2)}
+`, "utf8");
+      output.planPath = planPath;
+    } else {
+      output.planDetail = plan;
+    }
+  }
+  return JSON.stringify(output);
+}
+function toFlatNode(node) {
+  return {
+    id: node.id,
+    schemaIRI: node.schemaId,
+    ...node.properties,
+    updatedAt: node.updatedAt
+  };
+}
+function startDaemon(services, options) {
+  const rootDir = resolve(options.dir);
+  const report = options.onScan ?? ((summary) => console.log(summary));
+  const handleScan = async (scan) => {
+    if (scan.pendingPlans.length === 0 && scan.conflicts.length === 0) return;
+    if (options.apply && scan.pendingPlans.length > 0) {
+      const summary = await runCommit(services, {
+        dir: rootDir,
+        apply: true,
+        actor: options.actor
+      });
+      report(summary);
+      return;
+    }
+    report(
+      [
+        ...scan.pendingPlans.map((pending) => `planned	${pending.path}	${pending.plan.id}`),
+        ...scan.conflicts.map((conflict) => `conflict	${conflict.path}	${conflict.kind}`)
+      ].join("\n")
+    );
+  };
+  const handle = services.watcher.watchWorkspace(
+    {
+      rootDir,
+      actor: options.actor ?? "xnet-daemon",
+      usePolling: options.poll,
+      ...options.pollIntervalMs !== void 0 ? { pollIntervalMs: options.pollIntervalMs } : {}
+    },
+    (scan) => void handleScan(scan)
+  );
+  return handle;
+}
+function parseAssignments(pairs) {
+  const record = {};
+  for (const pair of pairs) {
+    const separator = pair.indexOf("=");
+    if (separator <= 0) {
+      throw new Error(`Invalid assignment "${pair}"; expected field=value`);
+    }
+    const field = pair.slice(0, separator).trim();
+    const raw = pair.slice(separator + 1);
+    try {
+      record[field] = JSON.parse(raw);
+    } catch {
+      record[field] = raw;
+    }
+  }
+  return record;
+}
+function registerAgentCommands(program2, createServices = defaultServicesFactory) {
+  const services = (options) => createServices(options);
+  const print = (text2) => {
+    console.log(text2);
+  };
+  program2.command("checkout").description("Materialize a scoped slice of the workspace into a vault folder").option("-q, --query <text>", "Search query scope").option("-s, --schema <iri...>", "Schema IRI scope").option("-n, --node <id...>", "Node id scope").option("-k, --kind <kind...>", "Kind folder scope: page|database|canvas").option("-l, --limit <n>", "Max nodes to materialize", parseIntOption).option("-d, --dir <path>", "Checkout directory", ".").option("--name <name>", "Workspace display name").option("--api-url <url>", "xNet local API URL").action(async (options) => {
+    print(await runCheckout(await services(options), options));
+  });
+  program2.command("status").description("List pending plans and conflicts for a checkout").option("-d, --dir <path>", "Checkout directory", ".").option("--format <format>", "Output format: tsv|json", "tsv").option("--api-url <url>", "xNet local API URL").action(async (options) => {
+    print(await runStatus(await services(options), options));
+  });
+  program2.command("commit").description("Lift file edits into mutation plans; --apply applies them").option("-d, --dir <path>", "Checkout directory", ".").option("--apply", "Apply valid plans through the plan pipeline").option("--actor <actor>", "Actor recorded on plans", "xnet-cli").option("--api-url <url>", "xNet local API URL").action(async (options) => {
+    print(await runCommit(await services(options), options));
+  });
+  program2.command("search <text>").description("Ranked workspace search (TSV: id, schema, title, snippet)").option("-s, --schema <iri>", "Schema IRI filter").option("-l, --limit <n>", "Max results", parseIntOption).option("--format <format>", "Output format: tsv|jsonl|json", "tsv").option("--api-url <url>", "xNet local API URL").action(async (text2, options) => {
+    print(await runSearch(await services(options), { ...options, text: text2 }));
+  });
+  program2.command("query <databaseId>").description("Query database rows (TSV by default)").option("-w, --where <expr...>", "Filters as field=value").option("-l, --limit <n>", "Max rows", parseIntOption).option("-o, --offset <n>", "Row offset", parseIntOption).option("--format <format>", "Output format: tsv|jsonl|json", "tsv").option("--detailed", "Include descriptor and query plan in json output").option("--api-url <url>", "xNet local API URL").action(async (databaseId, options) => {
+    print(await runQuery(await services(options), { ...options, databaseId }));
+  });
+  const db = program2.command("db").description("Direct node and row access");
+  db.command("get <nodeId>").description("Read a node as compact JSON").option("--detailed", "Include full node record").option("--api-url <url>", "xNet local API URL").action(async (nodeId, options) => {
+    print(await runDbGet(await services(options), { ...options, nodeId }));
+  });
+  db.command("set <databaseId> <rowId> <assignments...>").description("Update row properties through the plan/apply pipeline").option("--plan-only", "Print the mutation plan without applying").option("--actor <actor>", "Actor recorded on the plan", "xnet-cli").option("--api-url <url>", "xNet local API URL").action(async (databaseId, rowId, assignments, options) => {
+    print(
+      await runDbSet(await services(options), {
+        databaseId,
+        rowId,
+        assignments,
+        actor: options.actor,
+        planOnly: options.planOnly
+      })
+    );
+  });
+  program2.command("run <file>").description("Run a sandboxed agent script with the @xnet/agent-api surface").option("-s, --schema <iri>", "Preload nodes of this schema").option("-l, --limit <n>", "Max nodes to preload", parseIntOption).option("-n, --node <id>", "Current node id").option("-d, --dir <path>", "Checkout directory for proposal plans").option("--actor <actor>", "Actor recorded on proposal plans", "xnet-cli-script").option("--api-url <url>", "xNet local API URL").action(async (file, options) => {
+    print(await runScript(await services(options), { ...options, file }));
+  });
+  program2.command("daemon").description("Watch a checkout and lift saves into mutation plans").option("-d, --dir <path>", "Checkout directory", ".").option("--poll", "Use interval polling instead of fs.watch").option("--apply", "Auto-apply valid plans (watcher autocommit)").option("--actor <actor>", "Actor recorded on plans", "xnet-daemon").option("--api-url <url>", "xNet local API URL").action(async (options) => {
+    const handle = startDaemon(await services(options), options);
+    console.log(`watching ${resolve(options.dir)} (ctrl-c to stop)`);
+    process.on("SIGINT", () => {
+      handle.close();
+      process.exit(0);
+    });
+  });
+  program2.command("skill").description("Print the cross-harness xNet SKILL.md").action(() => {
+    print(XNET_AGENT_SKILL_MD);
+  });
+}
+function parseIntOption(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) throw new Error(`Invalid number: ${value}`);
+  return parsed;
+}
+
+// src/commands/bridge.ts
+import { writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import {
+  buildAgentArgs,
+  cliAgentRunner,
+  cliChatAgent,
+  createBridgeServer,
+  DEFAULT_BRIDGE_PORT,
+  defaultXnetGate,
+  Git,
+  handleBridgeRun,
+  mcpConfigFor,
+  NodeCommandRunner
+} from "@xnetjs/devkit";
+function buildBridgeServer(options, runner = new NodeCommandRunner()) {
+  const command = options.agent ?? "claude";
+  const cwd = options.cwd ?? process.cwd();
+  const args = buildAgentArgs(command, {
+    ...options.mcpConfigPath ? { mcpConfigPath: options.mcpConfigPath } : {}
+  });
+  const agent = cliChatAgent(runner, { command, cwd, args });
+  const run = options.code ? (request) => handleBridgeRun(
+    {
+      git: new Git(runner, cwd),
+      runner,
+      agent: cliAgentRunner(runner, { command }),
+      gate: defaultXnetGate(),
+      worktreeRoot: join2(cwd, ".xnet", "agent-worktrees")
+    },
+    request
+  ) : void 0;
+  return createBridgeServer({
+    agent,
+    agentName: command,
+    ...run ? { run } : {},
+    ...options.host ? { host: options.host } : {},
+    ...options.port !== void 0 ? { port: options.port } : {},
+    ...options.allowOrigin ? { allowedOrigins: options.allowOrigin } : {}
+  });
+}
+function registerBridgeCommand(program2) {
+  const bridge = program2.command("bridge").description("Run the local agent bridge for XNet's AI chat panel");
+  bridge.command("serve").description("Serve the agent bridge on loopback (default :31416), driving your own agent CLI").option("--agent <command>", "Agent CLI to drive (claude, codex, \u2026)", "claude").option("--host <host>", "Loopback host (default 127.0.0.1)").option("--port <n>", `Port (default ${DEFAULT_BRIDGE_PORT})`, parseIntOption2).option(
+    "--allow-origin <origin...>",
+    "Browser origins permitted (e.g. https://user.github.io for the web deployment)"
+  ).option("--cwd <dir>", "Working directory the agent runs in (default current dir)").option("--code", "Enable POST /run agentic code tasks (worktree \u2192 gate \u2192 checkpoint/PR)").option("--mcp", "Give the agent XNet's workspace tools via `xnet mcp serve`").option(
+    "--mcp-api-url <url>",
+    "xNet local API URL the MCP server talks to (default http://127.0.0.1:31415)"
+  ).action(async (options) => {
+    const resolved = { ...options };
+    if (options.mcp) {
+      const spec = {
+        command: process.execPath,
+        args: [
+          process.argv[1],
+          "mcp",
+          "serve",
+          "--api-url",
+          options.mcpApiUrl ?? "http://127.0.0.1:31415"
+        ]
+      };
+      const mcpConfigPath = join2(tmpdir(), `xnet-bridge-mcp-${process.pid}.json`);
+      writeFileSync(mcpConfigPath, JSON.stringify(mcpConfigFor(spec)));
+      resolved.mcpConfigPath = mcpConfigPath;
+    }
+    const handle = buildBridgeServer(resolved);
+    await handle.start();
+    console.error(
+      `xNet agent bridge listening on ${handle.url} (agent: ${options.agent ?? "claude"}${options.mcp ? ", workspace tools enabled" : ""})`
+    );
+    console.error('In XNet, open the AI panel and select "Local bridge".');
+    const shutdown = () => {
+      void handle.stop().then(() => process.exit(0));
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+}
+function parseIntOption2(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) throw new Error(`Invalid number: ${value}`);
+  return parsed;
+}
+
+// src/commands/code.ts
+import { join as join3, resolve as resolve2 } from "path";
+import {
+  cliAgentRunner as cliAgentRunner2,
+  defaultXnetGate as defaultXnetGate2,
+  Git as Git2,
+  NodeCommandRunner as NodeCommandRunner2,
+  openPullRequest,
+  runAgentTask
+} from "@xnetjs/devkit";
+function slug(text2) {
+  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "task";
+}
+function resolveCodeRunConfig(prompt, options, repoRoot, now = Date.now) {
+  const id = options.id ?? `code-${slug(prompt)}-${now().toString(36)}`;
+  const branch = options.branch ?? `agent/${id}`;
+  const base = options.base ?? "origin/main";
+  const worktreePath = options.worktree ? resolve2(options.worktree) : join3(repoRoot, ".xnet", "agent-worktrees", id);
+  return {
+    id,
+    branch,
+    base,
+    worktreePath,
+    gate: defaultXnetGate2({ changedSince: base }),
+    keepWorktree: Boolean(options.pr || options.keep)
+  };
+}
+function summarizeAgentTaskResult(result) {
+  if (!result.ok) {
+    if (result.rolledBack && result.gate.failedStep) {
+      return `\u2717 gate failed at "${result.gate.failedStep}" \u2014 edits rolled back on ${result.branch}.`;
+    }
+    return `\u2717 agent run failed on ${result.branch}.`;
+  }
+  if (result.noChanges) return `\u2022 agent made no changes on ${result.branch}.`;
+  return `\u2713 ${result.branch} passed the gate and was checkpointed.`;
+}
+function registerCodeCommand(program2) {
+  program2.command("code").argument("<intent>", "What the coding agent should do").description("Run a coding agent on this repo in an isolated worktree (gate \u2192 checkpoint/PR)").option("--agent <command>", "Coding agent CLI (claude, codex, aider, \u2026)", "claude").option("--id <id>", "Task id (also the default branch + worktree name)").option("--branch <name>", "Branch for the worktree (default agent/<id>)").option("--base <ref>", "Base ref for the gate + PR (default origin/main)").option("--worktree <dir>", "Worktree directory (default .xnet/agent-worktrees/<id>)").option("--pr", "Open a pull request when the gate passes").option("--keep", "Keep the worktree after a successful run").option("--repo <dir>", "Repo root (default current dir)").action(async (intent, options) => {
+    const runner = new NodeCommandRunner2();
+    const repoRoot = resolve2(options.repo ?? process.cwd());
+    const config = resolveCodeRunConfig(intent, options, repoRoot);
+    const result = await runAgentTask({
+      git: new Git2(runner, repoRoot),
+      runner,
+      agent: cliAgentRunner2(runner, { command: options.agent ?? "claude" }),
+      task: { id: config.id, prompt: intent },
+      worktreePath: config.worktreePath,
+      branch: config.branch,
+      gate: config.gate,
+      keepWorktree: config.keepWorktree
+    });
+    console.error(summarizeAgentTaskResult(result));
+    if (result.ok && !result.noChanges && options.pr) {
+      try {
+        const pr = await openPullRequest(runner, config.worktreePath, config.branch, {
+          base: config.base,
+          title: intent
+        });
+        console.error(`\u2192 PR: ${pr.url}`);
+      } catch (err) {
+        console.error(`\u2192 PR failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    process.exitCode = result.ok ? 0 : 1;
+  });
+}
+
+// src/commands/connector.ts
+import { resolve as resolve4 } from "path";
+import { scaffoldPlugin as scaffoldPlugin2 } from "@xnetjs/plugins";
+
+// src/commands/plugin.ts
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3, dirname as dirname2, join as join4 } from "path";
+import { scaffoldPlugin } from "@xnetjs/plugins";
+var TEMPLATES = ["client", "two-sided", "ai-script"];
+var nodeIO = {
+  mkdir: (path) => mkdirSync(path, { recursive: true }),
+  writeFile: (path, content) => writeFileSync2(path, content, "utf-8")
+};
+function writeScaffoldFiles(files, targetDir, io = nodeIO) {
+  const written = [];
+  for (const [rel, content] of Object.entries(files)) {
+    const full = join4(targetDir, rel);
+    io.mkdir(dirname2(full));
+    io.writeFile(full, content);
+    written.push(rel);
+  }
+  return written;
+}
+function resolveTemplate(value) {
+  const template = value ?? "client";
+  if (!TEMPLATES.includes(template)) {
+    throw new Error(`Unknown template "${value}". Use one of: ${TEMPLATES.join(", ")}`);
+  }
+  return template;
+}
+function scaffoldCommand(id, options) {
+  const template = resolveTemplate(options.template);
+  const { files } = scaffoldPlugin({
+    id,
+    name: options.name ?? id,
+    template,
+    author: options.author,
+    description: options.description
+  });
+  const targetDir = resolve3(process.cwd(), options.out ?? id);
+  const written = writeScaffoldFiles(files, targetDir);
+  console.log(`Scaffolded ${template} plugin "${id}" at ${targetDir}`);
+  for (const rel of written) console.log(`  + ${rel}`);
+  console.log("\nNext: cd into the project, `npm install`, then `npm test`.");
+}
+function registerPluginCommand(program2) {
+  const plugin = program2.command("plugin").description("Author and manage xNet plugins");
+  plugin.command("scaffold <id>").description("Scaffold a new plugin project (id is reverse-domain, e.g. com.acme.kanban)").option("--name <name>", "Human-readable plugin name").option("--template <template>", `Template: ${TEMPLATES.join(" | ")}`, "client").option("--author <author>", "Author name").option("--description <text>", "Short description").option("--out <dir>", "Output directory (default: the plugin id)").action((id, opts) => {
+    try {
+      scaffoldCommand(id, opts);
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/connector.ts
+function scaffoldConnector(id, options) {
+  const { files } = scaffoldPlugin2({
+    id,
+    name: options.name ?? id,
+    template: "connector",
+    author: options.author,
+    description: options.description
+  });
+  const targetDir = resolve4(process.cwd(), options.out ?? id);
+  const written = writeScaffoldFiles(files, targetDir);
+  console.log(`Scaffolded connector "${id}" at ${targetDir}`);
+  for (const rel of written) console.log(`  + ${rel}`);
+  console.log(
+    "\nNext: cd in, `npm install`, `npm test`. Then fill in the sync `pull` and register the hub half with `connectorSyncFeature` (see @xnetjs/hub)."
+  );
+}
+function registerConnectorCommand(program2) {
+  const connector = program2.command("connector").description("Author agent-native Connectors (sync an external service into governed nodes)");
+  connector.command("scaffold <id>").description(
+    "Scaffold a Connector project (id is reverse-domain, e.g. dev.acme.connector.slack)"
+  ).option("--name <name>", "Human-readable connector name").option("--author <author>", "Author name").option("--description <text>", "Short description").option("--out <dir>", "Output directory (default: the connector id)").action((id, opts) => {
+    try {
+      scaffoldConnector(id, opts);
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/data.ts
+import { generateSigningKeyPair, getSigningPublicKeyFromPrivate } from "@xnetjs/crypto";
+import { defineSchema, SQLiteNodeStorageAdapter, text } from "@xnetjs/data";
+import { createDID } from "@xnetjs/identity";
+import { createXNetClient } from "@xnetjs/runtime";
+import chalk from "chalk";
+var NoteSchema = defineSchema({
+  name: "Note",
+  namespace: "xnet://cli/",
+  properties: {
+    title: text({ required: true }),
+    body: text({})
+  }
+});
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return new Uint8Array(Buffer.from(clean, "hex"));
+}
+function resolveSigningKey(key) {
+  const provided = key ?? process.env.XNET_SIGNING_KEY;
+  if (provided) return { signingKey: hexToBytes(provided), ephemeral: false };
+  return { signingKey: generateSigningKeyPair().privateKey, ephemeral: true };
+}
+async function resolveStorage(db) {
+  if (db) {
+    const { createElectronSQLiteAdapter } = await import("@xnetjs/sqlite/electron");
+    const adapter2 = await createElectronSQLiteAdapter({
+      path: db,
+      busyTimeout: 5e3,
+      foreignKeys: true,
+      walMode: true
+    });
+    return new SQLiteNodeStorageAdapter(adapter2);
+  }
+  const { createMemorySQLiteAdapter } = await import("@xnetjs/sqlite/memory");
+  const adapter = await createMemorySQLiteAdapter();
+  return new SQLiteNodeStorageAdapter(adapter);
+}
+async function buildDataClient(options = {}) {
+  const { signingKey } = resolveSigningKey(options.key);
+  const authorDID = createDID(getSigningPublicKeyFromPrivate(signingKey));
+  const nodeStorage = await resolveStorage(options.db);
+  return createXNetClient({ nodeStorage, authorDID, signingKey });
+}
+async function runCreateNote(client, input) {
+  return client.mutate.create(NoteSchema, { title: input.title, body: input.body ?? "" });
+}
+async function runListNotes(client) {
+  return client.fetch(NoteSchema);
+}
+function registerDataCommand(program2) {
+  const data = program2.command("data").description("Read and write live nodes (runtime client)");
+  data.command("add").description("Create a Note node").requiredOption("--title <title>", "Note title").option("--body <body>", "Note body", "").option("--db <path>", "SQLite file path (default: in-memory)").option("--key <hex>", "Ed25519 signing key (hex); falls back to $XNET_SIGNING_KEY").action(async (opts) => {
+    const client = await buildDataClient({ db: opts.db, key: opts.key });
+    try {
+      const node = await runCreateNote(client, { title: opts.title, body: opts.body });
+      console.log(chalk.green(`\u2713 created ${node.id}`));
+      console.log(chalk.dim(`  author: ${client.authorDID}`));
+    } finally {
+      await client.destroy();
+    }
+  });
+  data.command("list").description("List Note nodes").option("--db <path>", "SQLite file path (default: in-memory)").option("--key <hex>", "Ed25519 signing key (hex); falls back to $XNET_SIGNING_KEY").action(async (opts) => {
+    const client = await buildDataClient({ db: opts.db, key: opts.key });
+    try {
+      const notes = await runListNotes(client);
+      if (notes.length === 0) {
+        console.log(chalk.dim("(no notes)"));
+        return;
+      }
+      for (const note of notes) {
+        const title = String(note.properties.title ?? "");
+        console.log(`${chalk.cyan(note.id)}  ${title}`);
+      }
+    } finally {
+      await client.destroy();
+    }
+  });
+}
+
 // src/commands/doctor.ts
-import { writeFileSync, readFileSync, existsSync, readdirSync, statSync } from "fs";
-import { resolve, join } from "path";
+import { writeFileSync as writeFileSync3, readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { resolve as resolve5, join as join5 } from "path";
 import {
   verifyIntegrity,
   quickIntegrityCheck,
@@ -22,8 +806,8 @@ import {
 } from "@xnetjs/sync";
 async function getChalk() {
   try {
-    const chalk = await import("chalk");
-    return chalk.default;
+    const chalk2 = await import("chalk");
+    return chalk2.default;
   } catch {
     const identity = (s) => s;
     return {
@@ -40,15 +824,15 @@ async function getChalk() {
 }
 function findDataDir(providedDir) {
   if (providedDir) {
-    const resolved = resolve(process.cwd(), providedDir);
+    const resolved = resolve5(process.cwd(), providedDir);
     if (existsSync(resolved)) {
       return resolved;
     }
     throw new Error(`Data directory not found: ${resolved}`);
   }
-  const commonPaths = [".xnet/data", "data", ".data", resolve(process.env.HOME ?? "", ".xnet/data")];
+  const commonPaths = [".xnet/data", "data", ".data", resolve5(process.env.HOME ?? "", ".xnet/data")];
   for (const path of commonPaths) {
-    const resolved = resolve(process.cwd(), path);
+    const resolved = resolve5(process.cwd(), path);
     if (existsSync(resolved)) {
       return resolved;
     }
@@ -59,7 +843,7 @@ function loadChangesFromDir(dataDir) {
   const changes = [];
   const patterns = ["changes.json", "changes/*.json", "*.changes.json"];
   for (const pattern of patterns) {
-    const changesFile = join(dataDir, pattern.split("/")[0]);
+    const changesFile = join5(dataDir, pattern.split("/")[0]);
     if (existsSync(changesFile) && statSync(changesFile).isFile()) {
       try {
         const content = readFileSync(changesFile, "utf-8");
@@ -73,12 +857,12 @@ function loadChangesFromDir(dataDir) {
       }
     }
   }
-  const changesDir = join(dataDir, "changes");
+  const changesDir = join5(dataDir, "changes");
   if (existsSync(changesDir) && statSync(changesDir).isDirectory()) {
     const files = readdirSync(changesDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       try {
-        const content = readFileSync(join(changesDir, file), "utf-8");
+        const content = readFileSync(join5(changesDir, file), "utf-8");
         const change = JSON.parse(content);
         changes.push(change);
       } catch {
@@ -92,114 +876,114 @@ function formatDuration(ms) {
   return `${(ms / 1e3).toFixed(2)}s`;
 }
 async function doctorCommand(options) {
-  const chalk = await getChalk();
-  console.log(chalk.bold("\nxNet Health Check\n"));
-  console.log(chalk.dim("\u2500".repeat(50)));
+  const chalk2 = await getChalk();
+  console.log(chalk2.bold("\nxNet Health Check\n"));
+  console.log(chalk2.dim("\u2500".repeat(50)));
   try {
     let dataDir;
     let changes = [];
     try {
       dataDir = findDataDir(options.dataDir);
-      console.log(chalk.gray(`Data directory: ${dataDir}`));
+      console.log(chalk2.gray(`Data directory: ${dataDir}`));
       changes = loadChangesFromDir(dataDir);
-      console.log(chalk.gray(`Found ${changes.length} changes`));
+      console.log(chalk2.gray(`Found ${changes.length} changes`));
     } catch {
-      console.log(chalk.yellow("\nNote: No data directory found."));
-      console.log(chalk.gray("Use --data-dir to specify a data directory."));
-      console.log(chalk.gray("Running with demo data...\n"));
+      console.log(chalk2.yellow("\nNote: No data directory found."));
+      console.log(chalk2.gray("Use --data-dir to specify a data directory."));
+      console.log(chalk2.gray("Running with demo data...\n"));
       changes = generateDemoChanges();
     }
     console.log();
-    console.log(chalk.bold("Checking data integrity..."));
+    console.log(chalk2.bold("Checking data integrity..."));
     const report = options.quick ? await quickIntegrityCheck(changes) : await verifyIntegrity(changes);
     if (options.json) {
       console.log(JSON.stringify(report, null, 2));
       return;
     }
-    printIntegrityResults(report, chalk, options.verbose);
+    printIntegrityResults(report, chalk2, options.verbose);
     console.log();
-    console.log(chalk.bold("Analyzing change chains..."));
+    console.log(chalk2.bold("Analyzing change chains..."));
     const orphans = findOrphans(changes);
     const roots = findRoots(changes);
     const heads = findHeads(changes);
     const depth = getChainDepth(changes);
-    console.log(`  ${chalk.green("\u2713")} Roots: ${roots.length}`);
-    console.log(`  ${chalk.green("\u2713")} Heads: ${heads.length}`);
-    console.log(`  ${chalk.green("\u2713")} Depth: ${depth}`);
+    console.log(`  ${chalk2.green("\u2713")} Roots: ${roots.length}`);
+    console.log(`  ${chalk2.green("\u2713")} Heads: ${heads.length}`);
+    console.log(`  ${chalk2.green("\u2713")} Depth: ${depth}`);
     if (orphans.length > 0) {
-      console.log(`  ${chalk.yellow("\u26A0")} Orphans: ${orphans.length}`);
+      console.log(`  ${chalk2.yellow("\u26A0")} Orphans: ${orphans.length}`);
     } else {
-      console.log(`  ${chalk.green("\u2713")} Orphans: 0`);
+      console.log(`  ${chalk2.green("\u2713")} Orphans: 0`);
     }
     console.log();
-    console.log(chalk.bold("Checking schema compatibility..."));
-    console.log(chalk.gray("  (Schema analysis requires @xnetjs/data integration)"));
+    console.log(chalk2.bold("Checking schema compatibility..."));
+    console.log(chalk2.gray("  (Schema analysis requires @xnetjs/data integration)"));
     console.log();
-    console.log(chalk.bold("Checking sync state..."));
-    console.log(chalk.gray("  (Sync analysis requires active SyncProvider)"));
+    console.log(chalk2.bold("Checking sync state..."));
+    console.log(chalk2.gray("  (Sync analysis requires active SyncProvider)"));
     console.log();
-    console.log(chalk.dim("\u2500".repeat(50)));
+    console.log(chalk2.dim("\u2500".repeat(50)));
     const hasErrors = report.summary.errors > 0;
     const hasWarnings = report.summary.warnings > 0 || orphans.length > 0;
     if (hasErrors) {
-      console.log(chalk.red(chalk.bold("Status: UNHEALTHY")));
-      console.log(chalk.red("  Data integrity issues detected. Run `xnet repair` to fix."));
+      console.log(chalk2.red(chalk2.bold("Status: UNHEALTHY")));
+      console.log(chalk2.red("  Data integrity issues detected. Run `xnet repair` to fix."));
     } else if (hasWarnings) {
-      console.log(chalk.yellow(chalk.bold("Status: HEALTHY with warnings")));
-      console.log(chalk.gray("  Some issues detected but data is intact."));
+      console.log(chalk2.yellow(chalk2.bold("Status: HEALTHY with warnings")));
+      console.log(chalk2.gray("  Some issues detected but data is intact."));
     } else {
-      console.log(chalk.green(chalk.bold("Status: HEALTHY")));
-      console.log(chalk.green("  All checks passed."));
+      console.log(chalk2.green(chalk2.bold("Status: HEALTHY")));
+      console.log(chalk2.green("  All checks passed."));
     }
     console.log();
   } catch (error) {
-    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
-function printIntegrityResults(report, chalk, verbose) {
+function printIntegrityResults(report, chalk2, verbose) {
   const { checked, valid, issues, summary, durationMs } = report;
   const percentage = checked > 0 ? Math.round(valid / checked * 100) : 100;
   if (issues.length === 0) {
-    console.log(`  ${chalk.green("\u2713")} ${checked} changes verified (${percentage}% valid)`);
-    console.log(`  ${chalk.green("\u2713")} Hash chains intact`);
-    console.log(`  ${chalk.green("\u2713")} No issues detected`);
-    console.log(chalk.gray(`  Completed in ${formatDuration(durationMs)}`));
+    console.log(`  ${chalk2.green("\u2713")} ${checked} changes verified (${percentage}% valid)`);
+    console.log(`  ${chalk2.green("\u2713")} Hash chains intact`);
+    console.log(`  ${chalk2.green("\u2713")} No issues detected`);
+    console.log(chalk2.gray(`  Completed in ${formatDuration(durationMs)}`));
   } else {
     console.log(
-      `  ${chalk.yellow("!")} ${checked} changes checked (${valid} valid, ${checked - valid} issues)`
+      `  ${chalk2.yellow("!")} ${checked} changes checked (${valid} valid, ${checked - valid} issues)`
     );
     if (summary.errors > 0) {
-      console.log(`  ${chalk.red("\u2717")} ${summary.errors} errors`);
+      console.log(`  ${chalk2.red("\u2717")} ${summary.errors} errors`);
     }
     if (summary.warnings > 0) {
-      console.log(`  ${chalk.yellow("\u26A0")} ${summary.warnings} warnings`);
+      console.log(`  ${chalk2.yellow("\u26A0")} ${summary.warnings} warnings`);
     }
-    console.log(chalk.gray(`  Completed in ${formatDuration(durationMs)}`));
+    console.log(chalk2.gray(`  Completed in ${formatDuration(durationMs)}`));
     if (verbose) {
       console.log();
-      console.log(chalk.bold("Issues by type:"));
+      console.log(chalk2.bold("Issues by type:"));
       for (const [type, count] of Object.entries(summary.byType)) {
         if (count > 0) {
           console.log(`  - ${type}: ${count}`);
         }
       }
       console.log();
-      console.log(chalk.bold("Details:"));
+      console.log(chalk2.bold("Details:"));
       for (const issue of issues.slice(0, 10)) {
-        const icon = issue.severity === "error" ? chalk.red("\u2717") : chalk.yellow("\u26A0");
+        const icon = issue.severity === "error" ? chalk2.red("\u2717") : chalk2.yellow("\u26A0");
         console.log(`  ${icon} [${issue.type}] ${issue.details}`);
         if (issue.repairAction) {
-          console.log(chalk.gray(`      \u2192 ${issue.repairAction.description}`));
+          console.log(chalk2.gray(`      \u2192 ${issue.repairAction.description}`));
         }
       }
       if (issues.length > 10) {
-        console.log(chalk.gray(`  ... and ${issues.length - 10} more`));
+        console.log(chalk2.gray(`  ... and ${issues.length - 10} more`));
       }
     }
     if (report.repairable) {
       console.log();
-      console.log(chalk.cyan(`  Run \`xnet repair\` to fix these issues.`));
+      console.log(chalk2.cyan(`  Run \`xnet repair\` to fix these issues.`));
     }
   }
 }
@@ -219,7 +1003,7 @@ function generateDemoChanges() {
       authorDID: demoAuthor,
       signature: new Uint8Array([1, 2, 3, 4]),
       wallTime: now - 1e4,
-      lamport: { time: 1, author: demoAuthor }
+      lamport: 1
     },
     {
       id: "change-2",
@@ -231,13 +1015,13 @@ function generateDemoChanges() {
       authorDID: demoAuthor,
       signature: new Uint8Array([5, 6, 7, 8]),
       wallTime: now - 5e3,
-      lamport: { time: 2, author: demoAuthor }
+      lamport: 2
     }
   ];
 }
 async function repairCommand(options) {
-  const chalk = await getChalk();
-  console.log(chalk.bold("\nxNet Data Repair\n"));
+  const chalk2 = await getChalk();
+  console.log(chalk2.bold("\nxNet Data Repair\n"));
   try {
     let dataDir;
     let changes = [];
@@ -245,15 +1029,15 @@ async function repairCommand(options) {
       dataDir = findDataDir(options.dataDir);
       changes = loadChangesFromDir(dataDir);
     } catch {
-      console.log(chalk.yellow("Note: No data directory found."));
-      console.log(chalk.gray("Using demo data for illustration.\n"));
+      console.log(chalk2.yellow("Note: No data directory found."));
+      console.log(chalk2.gray("Using demo data for illustration.\n"));
       dataDir = "";
       changes = generateDemoChanges();
     }
-    console.log(chalk.gray("Running integrity check..."));
+    console.log(chalk2.gray("Running integrity check..."));
     const report = await verifyIntegrity(changes);
     if (report.issues.length === 0) {
-      console.log(chalk.green("\n\u2713 No issues found. Nothing to repair."));
+      console.log(chalk2.green("\n\u2713 No issues found. Nothing to repair."));
       return;
     }
     console.log(`
@@ -262,7 +1046,7 @@ Found ${report.issues.length} issues:`);
     console.log(`  - ${report.summary.warnings} warnings`);
     console.log();
     if (options.dryRun) {
-      console.log(chalk.yellow("DRY RUN - No changes will be made\n"));
+      console.log(chalk2.yellow("DRY RUN - No changes will be made\n"));
     }
     const { remainingIssues, repairCount } = await attemptRepair(changes, report.issues);
     if (options.json) {
@@ -280,33 +1064,33 @@ Found ${report.issues.length} issues:`);
       );
       return;
     }
-    console.log(chalk.bold("Repair results:"));
-    console.log(`  ${chalk.green("\u2713")} Repaired: ${repairCount} issues`);
-    console.log(`  ${chalk.yellow("!")} Remaining: ${remainingIssues.length} issues`);
+    console.log(chalk2.bold("Repair results:"));
+    console.log(`  ${chalk2.green("\u2713")} Repaired: ${repairCount} issues`);
+    console.log(`  ${chalk2.yellow("!")} Remaining: ${remainingIssues.length} issues`);
     if (remainingIssues.length > 0) {
       console.log();
-      console.log(chalk.yellow("Issues that require manual intervention:"));
+      console.log(chalk2.yellow("Issues that require manual intervention:"));
       for (const issue of remainingIssues.slice(0, 5)) {
         console.log(`  - [${issue.type}] ${issue.details}`);
       }
       if (remainingIssues.length > 5) {
-        console.log(chalk.gray(`  ... and ${remainingIssues.length - 5} more`));
+        console.log(chalk2.gray(`  ... and ${remainingIssues.length - 5} more`));
       }
     }
     if (!options.dryRun && dataDir && repairCount > 0) {
       console.log();
-      console.log(chalk.gray("Note: Writing repaired changes requires NodeStore integration."));
-      console.log(chalk.gray("Changes are prepared but not written to disk."));
+      console.log(chalk2.gray("Note: Writing repaired changes requires NodeStore integration."));
+      console.log(chalk2.gray("Changes are prepared but not written to disk."));
     }
     console.log();
   } catch (error) {
-    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
 async function exportCommand(options) {
-  const chalk = await getChalk();
-  console.log(chalk.bold("\nxNet Data Export\n"));
+  const chalk2 = await getChalk();
+  console.log(chalk2.bold("\nxNet Data Export\n"));
   try {
     let dataDir;
     let changes = [];
@@ -314,14 +1098,14 @@ async function exportCommand(options) {
       dataDir = findDataDir(options.dataDir);
       changes = loadChangesFromDir(dataDir);
     } catch {
-      console.log(chalk.yellow("Note: No data directory found."));
-      console.log(chalk.gray("Using demo data for illustration.\n"));
+      console.log(chalk2.yellow("Note: No data directory found."));
+      console.log(chalk2.gray("Using demo data for illustration.\n"));
       dataDir = "";
       changes = generateDemoChanges();
     }
-    const outputPath = resolve(process.cwd(), options.output);
-    console.log(chalk.gray(`Source: ${dataDir || "demo data"}`));
-    console.log(chalk.gray(`Output: ${outputPath}`));
+    const outputPath = resolve5(process.cwd(), options.output);
+    console.log(chalk2.gray(`Source: ${dataDir || "demo data"}`));
+    console.log(chalk2.gray(`Output: ${outputPath}`));
     console.log();
     const exportData = {
       version: 1,
@@ -342,30 +1126,30 @@ async function exportCommand(options) {
     const content = options.pretty ? JSON.stringify(exportData, null, 2) : JSON.stringify(exportData);
     if (options.format === "jsonl") {
       const lines = exportData.changes.map((c) => JSON.stringify(c)).join("\n");
-      writeFileSync(outputPath, lines, "utf-8");
+      writeFileSync3(outputPath, lines, "utf-8");
     } else {
-      writeFileSync(outputPath, content, "utf-8");
+      writeFileSync3(outputPath, content, "utf-8");
     }
-    console.log(chalk.green(`\u2713 Exported ${changes.length} changes`));
-    console.log(chalk.gray(`  File size: ${Math.round(content.length / 1024)}KB`));
+    console.log(chalk2.green(`\u2713 Exported ${changes.length} changes`));
+    console.log(chalk2.gray(`  File size: ${Math.round(content.length / 1024)}KB`));
     console.log();
   } catch (error) {
-    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
 async function importCommand(options) {
-  const chalk = await getChalk();
-  console.log(chalk.bold("\nxNet Data Import\n"));
+  const chalk2 = await getChalk();
+  console.log(chalk2.bold("\nxNet Data Import\n"));
   try {
-    const inputPath = resolve(process.cwd(), options.input);
+    const inputPath = resolve5(process.cwd(), options.input);
     if (!existsSync(inputPath)) {
-      console.error(chalk.red(`Error: Input file not found: ${inputPath}`));
+      console.error(chalk2.red(`Error: Input file not found: ${inputPath}`));
       process.exit(1);
     }
-    console.log(chalk.gray(`Input: ${inputPath}`));
+    console.log(chalk2.gray(`Input: ${inputPath}`));
     if (options.dryRun) {
-      console.log(chalk.yellow("\nDRY RUN - No changes will be applied\n"));
+      console.log(chalk2.yellow("\nDRY RUN - No changes will be applied\n"));
     }
     const content = readFileSync(inputPath, "utf-8");
     let importData;
@@ -380,43 +1164,43 @@ async function importCommand(options) {
       const lines = content.split("\n").filter((l) => l.trim());
       importData = { changes: lines.map((l) => JSON.parse(l)) };
     }
-    console.log(chalk.gray(`Found ${importData.changes.length} changes to import`));
+    console.log(chalk2.gray(`Found ${importData.changes.length} changes to import`));
     console.log();
     const changes = importData.changes.map((c) => ({
       ...c,
       signature: typeof c.signature === "string" ? new Uint8Array(Buffer.from(c.signature, "base64")) : c.signature
     }));
-    console.log(chalk.bold("Verifying import data..."));
+    console.log(chalk2.bold("Verifying import data..."));
     const report = await quickIntegrityCheck(changes);
     if (report.issues.length > 0) {
-      console.log(chalk.yellow(`  \u26A0 ${report.issues.length} integrity issues found`));
+      console.log(chalk2.yellow(`  \u26A0 ${report.issues.length} integrity issues found`));
       if (report.summary.errors > 0) {
-        console.log(chalk.red(`  ${report.summary.errors} errors may prevent import`));
+        console.log(chalk2.red(`  ${report.summary.errors} errors may prevent import`));
       }
     } else {
-      console.log(chalk.green("  \u2713 All changes verified"));
+      console.log(chalk2.green("  \u2713 All changes verified"));
     }
     if (options.applyMigrations) {
       console.log();
-      console.log(chalk.bold("Checking for required migrations..."));
-      console.log(chalk.gray("  (Migration detection requires schema registry)"));
+      console.log(chalk2.bold("Checking for required migrations..."));
+      console.log(chalk2.gray("  (Migration detection requires schema registry)"));
     }
     console.log();
-    console.log(chalk.bold("Import summary:"));
+    console.log(chalk2.bold("Import summary:"));
     console.log(`  Changes: ${changes.length}`);
     console.log(`  Roots: ${findRoots(changes).length}`);
     console.log(`  Heads: ${findHeads(changes).length}`);
     console.log(`  Chain depth: ${getChainDepth(changes)}`);
     if (!options.dryRun) {
       console.log();
-      console.log(chalk.gray("Note: Writing imported changes requires NodeStore integration."));
-      console.log(chalk.gray("Changes are validated but not written to storage."));
+      console.log(chalk2.gray("Note: Writing imported changes requires NodeStore integration."));
+      console.log(chalk2.gray("Changes are validated but not written to storage."));
     }
     console.log();
-    console.log(chalk.green("\u2713 Import validation complete"));
+    console.log(chalk2.green("\u2713 Import validation complete"));
     console.log();
   } catch (error) {
-    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
@@ -435,13 +1219,90 @@ function registerDoctorCommand(program2) {
   });
 }
 
+// src/commands/mcp.ts
+import {
+  createMCPServer,
+  createMcpHttpServer
+} from "@xnetjs/plugins/node";
+var defaultBackendFactory = (options) => createRemoteAgentBackend(options);
+function buildMcpServer(backend) {
+  return createMCPServer({ store: backend.store, schemas: backend.schemas });
+}
+async function startMcpServe(backendFactory, options) {
+  const backend = await backendFactory({
+    ...options.apiUrl ? { apiUrl: options.apiUrl } : {}
+  });
+  const server = buildMcpServer(backend);
+  if (options.http) {
+    const http = createMcpHttpServer({
+      server,
+      ...options.pairingToken ? { pairingToken: options.pairingToken } : {},
+      ...options.allowOrigin && options.allowOrigin.length > 0 ? { allowedOrigins: options.allowOrigin } : {},
+      ...options.host ? { host: options.host } : {},
+      ...options.port !== void 0 ? { port: options.port } : {}
+    });
+    await http.start();
+    return { mode: "http", server, http, stop: () => http.stop() };
+  }
+  return {
+    mode: "stdio",
+    server,
+    stop: async () => {
+      server.stop();
+    }
+  };
+}
+function openClawHttpConfigSnippet(handle) {
+  return JSON.stringify(
+    {
+      mcp: {
+        servers: {
+          xnet: {
+            url: `${handle.url}${handle.path}`,
+            transport: "streamable-http",
+            headers: { "x-xnet-pairing": handle.pairingToken }
+          }
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+function registerMcpCommand(program2, backendFactory = defaultBackendFactory) {
+  const mcp = program2.command("mcp").description("Expose the workspace to MCP clients");
+  mcp.command("serve").description("Start an MCP server (stdio by default; --http for browser/OpenClaw clients)").option("--http", "Serve over hardened loopback HTTP instead of stdio").option("--host <host>", "Loopback host for --http (default 127.0.0.1)").option("--port <n>", "Port for --http (default 31416)", parseIntOption3).option(
+    "--allow-origin <origin...>",
+    "Browser origins permitted for --http (e.g. https://user.github.io)"
+  ).option("--pairing-token <token>", "Shared secret for --http (generated if omitted)").option("--api-url <url>", "xNet local API URL (default http://127.0.0.1:31415)").action(async (options) => {
+    const handle = await startMcpServe(backendFactory, options);
+    if (handle.mode === "http" && handle.http) {
+      console.error(`xNet MCP server listening on ${handle.http.url}${handle.http.path}`);
+      console.error(`pairing token: ${handle.http.pairingToken}`);
+      console.error("OpenClaw config:\n" + openClawHttpConfigSnippet(handle.http));
+      const shutdown = () => {
+        void handle.stop().then(() => process.exit(0));
+      };
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+      return;
+    }
+    await handle.server.startStdio();
+  });
+}
+function parseIntOption3(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) throw new Error(`Invalid number: ${value}`);
+  return parsed;
+}
+
 // src/commands/migrate.ts
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve as resolve6 } from "path";
 async function getChalk2() {
   try {
-    const chalk = await import("chalk");
-    return chalk.default;
+    const chalk2 = await import("chalk");
+    return chalk2.default;
   } catch {
     const identity = (s) => s;
     return {
@@ -490,7 +1351,7 @@ function findSchema(schemaIRI, schemas) {
   return null;
 }
 async function analyzeCommand(options) {
-  const chalk = await getChalk2();
+  const chalk2 = await getChalk2();
   try {
     const fromParsed = parseSchemaIRI(options.from);
     const toParsed = parseSchemaIRI(options.to);
@@ -501,8 +1362,8 @@ async function analyzeCommand(options) {
     const fromSchema = findSchema(options.from, schemas);
     const toSchema = findSchema(options.to, schemas);
     if (!fromSchema || !toSchema) {
-      console.log(chalk.yellow("\nNote: Schema file not provided. Showing example output.\n"));
-      console.log(chalk.gray("Use --schema-file to load actual schemas from a JSON file.\n"));
+      console.log(chalk2.yellow("\nNote: Schema file not provided. Showing example output.\n"));
+      console.log(chalk2.gray("Use --schema-file to load actual schemas from a JSON file.\n"));
       const mockFromSchema = {
         "@id": `xnet://xnet.fyi/${fromParsed.name}@${fromParsed.version}`,
         "@type": "xnet://xnet.fyi/Schema",
@@ -531,72 +1392,72 @@ async function analyzeCommand(options) {
           { "@id": `#priority`, name: "priority", type: "text", required: true }
         ]
       };
-      printAnalysisResult(diffSchemas(mockFromSchema, mockToSchema), options.json, chalk);
+      printAnalysisResult(diffSchemas(mockFromSchema, mockToSchema), options.json, chalk2);
       return;
     }
     const diff = diffSchemas(fromSchema, toSchema);
-    printAnalysisResult(diff, options.json, chalk);
+    printAnalysisResult(diff, options.json, chalk2);
   } catch (error) {
-    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
-function printAnalysisResult(diff, json, chalk) {
+function printAnalysisResult(diff, json, chalk2) {
   if (json) {
     console.log(JSON.stringify(diff, null, 2));
     return;
   }
-  console.log(chalk.bold(`
+  console.log(chalk2.bold(`
 Schema changes: ${diff.fromVersion} \u2192 ${diff.toVersion}
 `));
   if (diff.changes.length === 0) {
-    console.log(chalk.green("No changes detected."));
+    console.log(chalk2.green("No changes detected."));
     return;
   }
   const breaking = diff.changes.filter((c) => c.risk === "breaking");
   const caution = diff.changes.filter((c) => c.risk === "caution");
   const safe = diff.changes.filter((c) => c.risk === "safe");
   if (breaking.length > 0) {
-    console.log(chalk.red(chalk.bold("BREAKING CHANGES:")));
+    console.log(chalk2.red(chalk2.bold("BREAKING CHANGES:")));
     for (const change of breaking) {
-      console.log(chalk.red(`  - ${change.type.toUpperCase()}: ${change.description}`));
+      console.log(chalk2.red(`  - ${change.type.toUpperCase()}: ${change.description}`));
     }
     console.log();
   }
   if (caution.length > 0) {
-    console.log(chalk.yellow(chalk.bold("CAUTION:")));
+    console.log(chalk2.yellow(chalk2.bold("CAUTION:")));
     for (const change of caution) {
-      console.log(chalk.yellow(`  - ${change.type.toUpperCase()}: ${change.description}`));
+      console.log(chalk2.yellow(`  - ${change.type.toUpperCase()}: ${change.description}`));
     }
     console.log();
   }
   if (safe.length > 0) {
-    console.log(chalk.green(chalk.bold("SAFE:")));
+    console.log(chalk2.green(chalk2.bold("SAFE:")));
     for (const change of safe) {
-      console.log(chalk.green(`  - ${change.type.toUpperCase()}: ${change.description}`));
+      console.log(chalk2.green(`  - ${change.type.toUpperCase()}: ${change.description}`));
     }
     console.log();
   }
-  console.log(chalk.bold("Summary:"));
+  console.log(chalk2.bold("Summary:"));
   console.log(
-    `  ${chalk.red(`${diff.summary.breaking} breaking`)} | ${chalk.yellow(`${diff.summary.caution} caution`)} | ${chalk.green(`${diff.summary.safe} safe`)}`
+    `  ${chalk2.red(`${diff.summary.breaking} breaking`)} | ${chalk2.yellow(`${diff.summary.caution} caution`)} | ${chalk2.green(`${diff.summary.safe} safe`)}`
   );
   console.log();
   if (diff.changes.some((c) => c.suggestedLens)) {
-    console.log(chalk.bold("Suggested lens:"));
-    console.log(chalk.dim("\u2500".repeat(40)));
+    console.log(chalk2.bold("Suggested lens:"));
+    console.log(chalk2.dim("\u2500".repeat(40)));
     console.log(generateLensSnippet(diff));
-    console.log(chalk.dim("\u2500".repeat(40)));
+    console.log(chalk2.dim("\u2500".repeat(40)));
     console.log();
   }
   if (diff.autoMigratable) {
-    console.log(chalk.green("\u2713 Automatic migration possible"));
+    console.log(chalk2.green("\u2713 Automatic migration possible"));
   } else {
-    console.log(chalk.yellow("\u26A0 Manual intervention required for some changes"));
+    console.log(chalk2.yellow("\u26A0 Manual intervention required for some changes"));
   }
 }
 async function generateCommand(options) {
-  const chalk = await getChalk2();
+  const chalk2 = await getChalk2();
   try {
     const fromParsed = parseSchemaIRI(options.from);
     const toParsed = parseSchemaIRI(options.to);
@@ -609,7 +1470,7 @@ async function generateCommand(options) {
     const from = fromSchema ?? createMockSchema(fromParsed.name, fromParsed.version, "from");
     const to = toSchema ?? createMockSchema(toParsed.name, toParsed.version, "to");
     if (!fromSchema || !toSchema) {
-      console.log(chalk.yellow("\nNote: Using mock schemas for demonstration.\n"));
+      console.log(chalk2.yellow("\nNote: Using mock schemas for demonstration.\n"));
     }
     const diff = diffSchemas(from, to);
     const sourceIRI = from["@id"];
@@ -622,26 +1483,26 @@ async function generateCommand(options) {
       includeTodos: true
     });
     if (options.output) {
-      const outputPath = resolve2(process.cwd(), options.output);
+      const outputPath = resolve6(process.cwd(), options.output);
       if (existsSync2(outputPath) && !options.force) {
-        console.error(chalk.red(`Error: File already exists: ${outputPath}`));
-        console.error(chalk.gray("Use --force to overwrite."));
+        console.error(chalk2.red(`Error: File already exists: ${outputPath}`));
+        console.error(chalk2.gray("Use --force to overwrite."));
         process.exit(1);
       }
-      writeFileSync2(outputPath, generated.code, "utf-8");
-      console.log(chalk.green(`
+      writeFileSync4(outputPath, generated.code, "utf-8");
+      console.log(chalk2.green(`
 \u2713 Generated lens written to: ${outputPath}`));
     } else {
       console.log(generated.code);
     }
     if (!generated.isComplete) {
-      console.log(chalk.yellow("\n\u26A0 Manual completion required:"));
+      console.log(chalk2.yellow("\n\u26A0 Manual completion required:"));
       for (const item of generated.manualItems) {
-        console.log(chalk.yellow(`  - ${item}`));
+        console.log(chalk2.yellow(`  - ${item}`));
       }
     }
   } catch (error) {
-    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
@@ -679,43 +1540,43 @@ function createMockSchema(name, version, type) {
   }
 }
 async function runCommand(options) {
-  const chalk = await getChalk2();
+  const chalk2 = await getChalk2();
   if (!options.dryRun && !options.apply) {
-    console.error(chalk.red("Error: Must specify either --dry-run or --apply"));
+    console.error(chalk2.red("Error: Must specify either --dry-run or --apply"));
     process.exit(1);
   }
   if (options.dryRun && options.apply) {
-    console.error(chalk.red("Error: Cannot specify both --dry-run and --apply"));
+    console.error(chalk2.red("Error: Cannot specify both --dry-run and --apply"));
     process.exit(1);
   }
   try {
-    console.log(chalk.blue(`
+    console.log(chalk2.blue(`
 Migration: ${options.from} \u2192 ${options.to}
 `));
     if (options.dryRun) {
-      console.log(chalk.yellow("DRY RUN - No changes will be applied\n"));
-      console.log(chalk.gray("Would migrate nodes:"));
-      console.log(chalk.gray("  - Scan data directory for nodes with schema " + options.from));
-      console.log(chalk.gray("  - Apply migration lens to each node"));
-      console.log(chalk.gray("  - Update schema version to " + options.to));
+      console.log(chalk2.yellow("DRY RUN - No changes will be applied\n"));
+      console.log(chalk2.gray("Would migrate nodes:"));
+      console.log(chalk2.gray("  - Scan data directory for nodes with schema " + options.from));
+      console.log(chalk2.gray("  - Apply migration lens to each node"));
+      console.log(chalk2.gray("  - Update schema version to " + options.to));
       console.log();
-      console.log(chalk.dim("Note: Full migration requires --data-dir and --lens-file options"));
-      console.log(chalk.dim("      or a configured NodeStore with registered lenses."));
+      console.log(chalk2.dim("Note: Full migration requires --data-dir and --lens-file options"));
+      console.log(chalk2.dim("      or a configured NodeStore with registered lenses."));
     } else {
-      console.log(chalk.yellow("APPLY MODE - Changes will be written\n"));
-      console.log(chalk.gray("Would apply migration:"));
-      console.log(chalk.gray("  - Load nodes with schema " + options.from));
-      console.log(chalk.gray("  - Transform using migration lens"));
-      console.log(chalk.gray("  - Write updated nodes with schema " + options.to));
+      console.log(chalk2.yellow("APPLY MODE - Changes will be written\n"));
+      console.log(chalk2.gray("Would apply migration:"));
+      console.log(chalk2.gray("  - Load nodes with schema " + options.from));
+      console.log(chalk2.gray("  - Transform using migration lens"));
+      console.log(chalk2.gray("  - Write updated nodes with schema " + options.to));
       console.log();
-      console.log(chalk.dim("Note: Full migration requires --data-dir and --lens-file options"));
-      console.log(chalk.dim("      or a configured NodeStore with registered lenses."));
+      console.log(chalk2.dim("Note: Full migration requires --data-dir and --lens-file options"));
+      console.log(chalk2.dim("      or a configured NodeStore with registered lenses."));
     }
     console.log();
-    console.log(chalk.green("\u2713 Migration command parsed successfully"));
-    console.log(chalk.gray("  Full implementation requires NodeStore integration."));
+    console.log(chalk2.green("\u2713 Migration command parsed successfully"));
+    console.log(chalk2.gray("  Full implementation requires NodeStore integration."));
   } catch (error) {
-    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
     process.exit(1);
   }
 }
@@ -733,7 +1594,7 @@ function registerMigrateCommand(program2) {
 }
 
 // src/commands/schema.ts
-import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { writeFileSync as writeFileSync5, readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
 function extractSchemas() {
   const schemaExportPath = process.env.XNET_SCHEMA_EXPORT || "./schemas-export.json";
   if (existsSync3(schemaExportPath)) {
@@ -758,7 +1619,7 @@ function registerSchemaCommand(program2) {
       schemas
     };
     const json = options.pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output);
-    writeFileSync3(options.output, json, "utf-8");
+    writeFileSync5(options.output, json, "utf-8");
     console.log(`Extracted ${schemas.length} schemas to ${options.output}`);
   });
   schema.command("diff").description("Compare two schema files and report changes").argument("<old-file>", "Path to the old schemas JSON file").argument("<new-file>", "Path to the new schemas JSON file").option("-o, --output <file>", "Output diff to JSON file").option("--fail-on-breaking", "Exit with code 1 if breaking changes found", false).option("--quiet", "Only output JSON, no console messages", false).action(
@@ -850,7 +1711,7 @@ function registerSchemaCommand(program2) {
         }
       };
       if (options.output) {
-        writeFileSync3(options.output, JSON.stringify(output, null, 2), "utf-8");
+        writeFileSync5(options.output, JSON.stringify(output, null, 2), "utf-8");
       }
       if (!options.quiet) {
         if (diffs.length === 0) {
@@ -887,4 +1748,11 @@ program.name("xnet").description("xNet CLI - Schema migrations, diagnostics, and
 registerMigrateCommand(program);
 registerSchemaCommand(program);
 registerDoctorCommand(program);
+registerAgentCommands(program);
+registerMcpCommand(program);
+registerBridgeCommand(program);
+registerCodeCommand(program);
+registerDataCommand(program);
+registerPluginCommand(program);
+registerConnectorCommand(program);
 program.parse();