@holoscript/core 6.0.3 → 7.0.0

package/dist/cli/holoscript-runner.js

@@ -1,2233 +0,0 @@
-#!/usr/bin/env node
-import { generateProvenance, checkLicenseCompatibility, ethToWei, calculateRevenueDistribution, formatRevenueDistribution, PROTOCOL_CONSTANTS, CompositionTestRunner, registerStdlib } from '../chunk-AW7WAELW.js';
-import { AbsorbProcessor, ScriptTestRunner, HotReloadWatcher } from '../chunk-GC3YU46J.js';
-import { InteropContext } from '../chunk-FF3Q7ADR.js';
-import { parse } from '../chunk-CMYAWUX3.js';
-import '../chunk-DXVCEFZB.js';
-import '../chunk-H7XMORZI.js';
-import '../chunk-26TLYBFD.js';
-import '../chunk-SUCBB66F.js';
-import '../chunk-XNMEH2BI.js';
-import '../chunk-32TWR3HE.js';
-import 'dotenv/config';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as readline from 'readline';
-import { spawn } from 'child_process';
-import { randomUUID } from 'crypto';
-import { createHeadlessRuntime, HEADLESS_PROFILE, getProfile } from '@holoscript/engine/runtime';
-
-function defaultModelForProvider(provider) {
-  switch (provider) {
-    case "xai":
-      return "grok-3";
-    case "openai":
-      return "gpt-4.1";
-    case "ollama":
-      return "brittney-qwen-v23:latest";
-    case "anthropic":
-    default:
-      return "claude-sonnet-4-20250514";
-  }
-}
-function defaultToolProfileForProvider(provider) {
-  switch (provider) {
-    case "xai":
-      return "grok-hsplus";
-    case "anthropic":
-      return "claude-hsplus";
-    case "openai":
-    case "ollama":
-    default:
-      return "standard";
-  }
-}
-function parseProvider(value) {
-  const normalized = value?.toLowerCase();
-  if (normalized === "anthropic" || normalized === "xai" || normalized === "openai" || normalized === "ollama") {
-    return normalized;
-  }
-  return void 0;
-}
-function parseToolProfile(value) {
-  const normalized = value?.toLowerCase();
-  if (normalized === "claude-hsplus" || normalized === "grok-hsplus" || normalized === "standard") {
-    return normalized;
-  }
-  return void 0;
-}
-function daemonEnvDefaults() {
-  const provider = parseProvider(process.env.HOLODAEMON_PROVIDER) || "anthropic";
-  const toolProfile = parseToolProfile(process.env.HOLODAEMON_TOOL_PROFILE) || defaultToolProfileForProvider(provider);
-  const model = process.env.HOLODAEMON_MODEL || defaultModelForProvider(provider);
-  return { provider, toolProfile, model };
-}
-function parseArgs(argv) {
-  const args = argv.slice(2);
-  const envDefaults = daemonEnvDefaults();
-  const opts = {
-    command: "help",
-    json: false,
-    target: "headless",
-    profile: "headless",
-    debug: false,
-    watch: false,
-    daemon: false,
-    ticks: 100,
-    cycles: 15,
-    commit: false,
-    enforceGotchas: false,
-    providerRotation: false,
-    alwaysOn: false,
-    cycleIntervalSec: 30,
-    allowShell: false,
-    allowedShellCommands: [],
-    allowedHosts: [],
-    allowedPaths: [],
-    provider: envDefaults.provider,
-    toolProfile: envDefaults.toolProfile,
-    model: envDefaults.model,
-    timeout: 30,
-    sessionId: randomUUID(),
-    // Deploy defaults
-    share: false,
-    author: "",
-    license: "free",
-    serverUrl: "https://mcp.holoscript.net",
-    // Protocol publish defaults
-    publish: false,
-    mintNft: false,
-    price: "0",
-    walletKey: ""
-  };
-  let modelExplicit = false;
-  let toolProfileExplicit = false;
-  if (args.length === 0) return opts;
-  const cmd = args[0];
-  if (cmd === "run" || cmd === "test" || cmd === "compile" || cmd === "deploy" || cmd === "absorb" || cmd === "daemon" || cmd === "holodaemon" || cmd === "moltbook-daemon" || cmd === "holomesh-daemon") {
-    opts.command = cmd;
-  }
-  if (opts.command === "daemon" && args[1] === "status") {
-    opts.command = "daemon-status";
-  }
-  if (args[1] && !args[1].startsWith("--") && opts.command !== "daemon-status") {
-    opts.file = args[1];
-  }
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--target" && args[i + 1]) opts.target = args[++i];
-    if (args[i] === "--profile" && args[i + 1]) opts.profile = args[++i];
-    if (args[i] === "--output" && args[i + 1]) opts.output = args[++i];
-    if (args[i] === "--tier" && args[i + 1]) {
-      const tier = args[++i].toLowerCase();
-      if (["low", "med", "high", "ultra"].includes(tier)) {
-        opts.qualityTier = tier;
-      }
-    }
-    if (args[i] === "--debug" || args[i] === "--verbose") opts.debug = true;
-    if (args[i] === "--watch" || args[i] === "-w") opts.watch = true;
-    if (args[i] === "--daemon") opts.daemon = true;
-    if (args[i] === "--ticks" && args[i + 1]) {
-      const parsed = Number(args[++i]);
-      if (Number.isFinite(parsed) && parsed >= 0) {
-        opts.ticks = Math.floor(parsed);
-      }
-    }
-    if (args[i] === "--cycles" && args[i + 1]) {
-      const parsed = Number(args[++i]);
-      if (Number.isFinite(parsed) && parsed > 0) {
-        opts.cycles = Math.floor(parsed);
-      }
-    }
-    if (args[i] === "--commit") opts.commit = true;
-    if (args[i] === "--trial" && args[i + 1]) {
-      opts.trial = Number(args[++i]);
-    }
-    if (args[i] === "--provider" && args[i + 1]) {
-      const provider = parseProvider(args[++i]);
-      if (provider) {
-        opts.provider = provider;
-      }
-    }
-    if (args[i] === "--tool-profile" && args[i + 1]) {
-      const profile = parseToolProfile(args[++i]);
-      if (profile) {
-        opts.toolProfile = profile;
-        toolProfileExplicit = true;
-      }
-    }
-    if (args[i] === "--model" && args[i + 1]) {
-      opts.model = args[++i];
-      modelExplicit = true;
-    }
-    if (args[i] === "--timeout" && args[i + 1]) {
-      const parsed = Number(args[++i]);
-      if (Number.isFinite(parsed) && parsed > 0) {
-        opts.timeout = Math.min(120, Math.max(1, Math.floor(parsed)));
-      }
-    }
-    if (args[i] === "--focus" && args[i + 1]) {
-      opts.focus = args[++i];
-    }
-    if (args[i] === "--enforce-gotchas") opts.enforceGotchas = true;
-    if (args[i] === "--provider-rotation") opts.providerRotation = true;
-    if (args[i] === "--always-on") opts.alwaysOn = true;
-    if (args[i] === "--allow-shell") opts.allowShell = true;
-    if (args[i] === "--skills-dir" && args[i + 1]) opts.skillsDir = args[++i];
-    if (args[i] === "--cycle-interval-sec" && args[i + 1]) {
-      const parsed = Number(args[++i]);
-      if (Number.isFinite(parsed) && parsed >= 1) {
-        opts.cycleIntervalSec = Math.floor(parsed);
-      }
-    }
-    if (args[i] === "--allow-shell-command" && args[i + 1]) {
-      opts.allowedShellCommands.push(args[++i]);
-    }
-    if (args[i] === "--allow-host" && args[i + 1]) {
-      opts.allowedHosts.push(args[++i]);
-    }
-    if (args[i] === "--allow-path" && args[i + 1]) {
-      opts.allowedPaths.push(args[++i]);
-    }
-    if (args[i] === "--json") opts.json = true;
-    if (args[i] === "--share") opts.share = true;
-    if (args[i] === "--author" && args[i + 1]) opts.author = args[++i];
-    if (args[i] === "--license" && args[i + 1]) opts.license = args[++i];
-    if (args[i] === "--server" && args[i + 1]) opts.serverUrl = args[++i];
-    if (args[i] === "--publish") opts.publish = true;
-    if (args[i] === "--mint-nft") opts.mintNft = true;
-    if (args[i] === "--price" && args[i + 1]) opts.price = args[++i];
-    if (args[i] === "--wallet-key" && args[i + 1]) opts.walletKey = args[++i];
-  }
-  if (!modelExplicit) {
-    opts.model = defaultModelForProvider(opts.provider);
-  }
-  if (!toolProfileExplicit) {
-    opts.toolProfile = defaultToolProfileForProvider(opts.provider);
-  }
-  return opts;
-}
-function extractChatText(data) {
-  const d = data;
-  return d?.content?.[0]?.text ?? d?.choices?.[0]?.message?.content ?? d?.message?.content ?? d?.response ?? "";
-}
-function extractTokenUsage(data) {
-  const d = data;
-  const inputTokens = d?.usage?.input_tokens ?? d?.usage?.prompt_tokens ?? d?.prompt_eval_count ?? 0;
-  const outputTokens = d?.usage?.output_tokens ?? d?.usage?.completion_tokens ?? d?.eval_count ?? 0;
-  return {
-    inputTokens: Number.isFinite(inputTokens) ? Number(inputTokens) : 0,
-    outputTokens: Number.isFinite(outputTokens) ? Number(outputTokens) : 0
-  };
-}
-function createDaemonLLMProvider(opts) {
-  if (opts.provider === "anthropic") {
-    return {
-      chat: async ({ system, prompt, maxTokens }) => {
-        const apiKey = process.env.ANTHROPIC_API_KEY;
-        if (!apiKey) throw new Error("ANTHROPIC_API_KEY not set");
-        const response = await fetch("https://api.anthropic.com/v1/messages", {
-          method: "POST",
-          headers: {
-            "x-api-key": apiKey,
-            "anthropic-version": "2023-06-01",
-            "content-type": "application/json"
-          },
-          body: JSON.stringify({
-            model: opts.model,
-            max_tokens: maxTokens || 4096,
-            system,
-            messages: [{ role: "user", content: prompt }]
-          })
-        });
-        if (!response.ok) {
-          const body = await response.text().catch(() => "");
-          throw new Error(`Anthropic API ${response.status}: ${body.slice(0, 200)}`);
-        }
-        const data = await response.json();
-        const usage = extractTokenUsage(data);
-        return {
-          text: extractChatText(data),
-          inputTokens: usage.inputTokens,
-          outputTokens: usage.outputTokens
-        };
-      }
-    };
-  }
-  if (opts.provider === "xai") {
-    return {
-      chat: async ({ system, prompt, maxTokens }) => {
-        const apiKey = process.env.XAI_API_KEY;
-        if (!apiKey) throw new Error("XAI_API_KEY not set");
-        const response = await fetch("https://api.x.ai/v1/chat/completions", {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "content-type": "application/json"
-          },
-          body: JSON.stringify({
-            model: opts.model,
-            max_tokens: maxTokens || 4096,
-            temperature: 0.2,
-            messages: [
-              { role: "system", content: system },
-              { role: "user", content: prompt }
-            ]
-          })
-        });
-        if (!response.ok) {
-          const body = await response.text().catch(() => "");
-          throw new Error(`xAI API ${response.status}: ${body.slice(0, 200)}`);
-        }
-        const data = await response.json();
-        const usage = extractTokenUsage(data);
-        return {
-          text: extractChatText(data),
-          inputTokens: usage.inputTokens,
-          outputTokens: usage.outputTokens
-        };
-      }
-    };
-  }
-  if (opts.provider === "openai") {
-    return {
-      chat: async ({ system, prompt, maxTokens }) => {
-        const apiKey = process.env.OPENAI_API_KEY;
-        if (!apiKey) throw new Error("OPENAI_API_KEY not set");
-        const baseUrl = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
-        const response = await fetch(`${baseUrl}/chat/completions`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "content-type": "application/json"
-          },
-          body: JSON.stringify({
-            model: opts.model,
-            max_tokens: maxTokens || 4096,
-            temperature: 0.2,
-            messages: [
-              { role: "system", content: system },
-              { role: "user", content: prompt }
-            ]
-          })
-        });
-        if (!response.ok) {
-          const body = await response.text().catch(() => "");
-          throw new Error(`OpenAI API ${response.status}: ${body.slice(0, 200)}`);
-        }
-        const data = await response.json();
-        const usage = extractTokenUsage(data);
-        return {
-          text: extractChatText(data),
-          inputTokens: usage.inputTokens,
-          outputTokens: usage.outputTokens
-        };
-      }
-    };
-  }
-  return {
-    chat: async ({ system, prompt }) => {
-      const baseUrl = process.env.OLLAMA_BASE_URL || process.env.OLLAMA_URL;
-      if (!baseUrl) throw new Error("Ollama selected but OLLAMA_BASE_URL/OLLAMA_URL not set. Use --provider anthropic|xai|openai or set OLLAMA_BASE_URL in .env");
-      const response = await fetch(`${baseUrl}/api/generate`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          model: opts.model,
-          system,
-          prompt,
-          stream: false,
-          options: {
-            temperature: 0.2
-          }
-        })
-      });
-      if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        throw new Error(`Ollama API ${response.status}: ${body.slice(0, 200)}`);
-      }
-      const data = await response.json();
-      const usage = extractTokenUsage(data);
-      return {
-        text: extractChatText(data),
-        inputTokens: usage.inputTokens,
-        outputTokens: usage.outputTokens
-      };
-    }
-  };
-}
-function createNodeHostCapabilities(cwd) {
-  return {
-    fileSystem: {
-      readFile: (filePath) => fs.readFileSync(path.resolve(cwd, filePath), "utf-8"),
-      writeFile: (filePath, content) => {
-        fs.writeFileSync(path.resolve(cwd, filePath), content, "utf-8");
-      },
-      deleteFile: (filePath) => {
-        fs.rmSync(path.resolve(cwd, filePath), { force: true });
-      },
-      exists: (filePath) => fs.existsSync(path.resolve(cwd, filePath))
-    },
-    process: {
-      exec: (command, args = [], options) => new Promise((resolve2, reject) => {
-        const child = spawn(command, args, {
-          cwd: options?.cwd ?? cwd,
-          env: { ...process.env, ...options?.env ?? {} },
-          shell: true,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        let stdout = "";
-        let stderr = "";
-        let timeoutHandle = null;
-        child.stdout?.on("data", (data) => {
-          stdout += data.toString("utf-8");
-        });
-        child.stderr?.on("data", (data) => {
-          stderr += data.toString("utf-8");
-        });
-        if (options?.timeoutMs && options.timeoutMs > 0) {
-          timeoutHandle = setTimeout(() => {
-            try {
-              child.kill("SIGKILL");
-            } catch {
-            }
-          }, options.timeoutMs);
-        }
-        child.on("close", (code, signal) => {
-          if (timeoutHandle) clearTimeout(timeoutHandle);
-          resolve2({ code, signal, stdout, stderr });
-        });
-        child.on("error", (error) => {
-          if (timeoutHandle) clearTimeout(timeoutHandle);
-          reject(error);
-        });
-      })
-    },
-    network: {
-      fetch: async (url, options) => {
-        if (typeof fetch === "undefined") {
-          throw new Error("fetch is not available in this runtime");
-        }
-        const response = await fetch(url, {
-          method: options?.method,
-          headers: options?.headers,
-          body: options?.body,
-          credentials: options?.credentials
-        });
-        const headers = {};
-        response.headers.forEach((value, key) => {
-          headers[key.toLowerCase()] = value;
-        });
-        const contentType = headers["content-type"] ?? "";
-        let body;
-        let text;
-        let json;
-        if (contentType.includes("application/json")) {
-          try {
-            json = await response.json();
-            body = json;
-          } catch {
-            text = await response.text();
-            body = text;
-          }
-        } else {
-          text = await response.text();
-          body = text;
-        }
-        return {
-          status: response.status,
-          ok: response.ok,
-          headers,
-          body,
-          text,
-          json
-        };
-      }
-    }
-  };
-}
-function runTicks(runtime, count) {
-  for (let i = 0; i < count; i++) {
-    runtime.tick();
-  }
-}
-async function runDaemon(runtime, opts) {
-  const supportsEvents = typeof runtime.emit === "function";
-  const supportsStats = typeof runtime.getStats === "function";
-  const supportsActionRegistry = typeof runtime.registerAction === "function";
-  const supportsSubscriptions = typeof runtime.on === "function";
-  const pendingActionResolutions = /* @__PURE__ */ new Map();
-  const registeredActions = /* @__PURE__ */ new Set();
-  let nextActionId = 1;
-  const send = (message) => {
-    process.stdout.write(`${JSON.stringify(message)}
-`);
-  };
-  const unsubscribeActionResult = supportsSubscriptions ? runtime.on("action:result", (payload) => {
-    send({
-      type: "daemon:action_result",
-      payload
-    });
-  }) : () => {
-  };
-  send({
-    type: "daemon:ready",
-    profile: opts.profile,
-    supportsEvents,
-    supportsStats,
-    supportsActionRegistry
-  });
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: false
-  });
-  const close = () => {
-    for (const [, pending] of pendingActionResolutions) {
-      clearTimeout(pending.timer);
-      pending.reject(new Error("Daemon shutting down"));
-    }
-    pendingActionResolutions.clear();
-    try {
-      unsubscribeActionResult();
-    } catch {
-    }
-    try {
-      runtime.stop();
-    } catch {
-    }
-    rl.close();
-  };
-  process.once("SIGINT", () => {
-    send({ type: "daemon:stopped", reason: "SIGINT" });
-    close();
-  });
-  process.once("SIGTERM", () => {
-    send({ type: "daemon:stopped", reason: "SIGTERM" });
-    close();
-  });
-  rl.on("line", (line) => {
-    const raw = line.trim();
-    if (!raw) return;
-    let command;
-    try {
-      command = JSON.parse(raw);
-    } catch {
-      send({ type: "daemon:error", error: "Invalid JSON command" });
-      return;
-    }
-    const op = command?.op;
-    switch (op) {
-      case "tick": {
-        const count = Number.isFinite(command?.count) ? Math.max(0, Math.floor(command.count)) : 1;
-        runTicks(runtime, count);
-        send({ type: "daemon:ok", op, ticked: count, stats: runtime.getStats?.() });
-        break;
-      }
-      case "emit": {
-        if (!supportsEvents) {
-          send({ type: "daemon:error", op, error: "Runtime does not expose emit()" });
-          break;
-        }
-        runtime.emit(command.event, command.payload);
-        send({ type: "daemon:ok", op, event: command.event });
-        break;
-      }
-      case "state:get": {
-        const key = command?.key;
-        const value = typeof key === "string" ? runtime.getState(key) : runtime.getAllState?.();
-        send({ type: "daemon:ok", op, key, value });
-        break;
-      }
-      case "state:set": {
-        const key = command?.key;
-        if (typeof key === "string") {
-          runtime.setState(key, command.value);
-          send({ type: "daemon:ok", op, key });
-        } else {
-          send({ type: "daemon:error", op, error: "state:set requires string key" });
-        }
-        break;
-      }
-      case "stats": {
-        send({ type: "daemon:ok", op, stats: runtime.getStats?.() });
-        break;
-      }
-      case "action:register": {
-        if (!supportsActionRegistry) {
-          send({ type: "daemon:error", op, error: "Runtime does not expose registerAction()" });
-          break;
-        }
-        const actionName = command?.name;
-        if (typeof actionName !== "string" || actionName.trim() === "") {
-          send({ type: "daemon:error", op, error: "action:register requires non-empty name" });
-          break;
-        }
-        runtime.registerAction(
-          actionName,
-          (params, blackboard) => {
-            const actionRequestId = `daemon-action-${nextActionId++}`;
-            const timeoutMs = Number.isFinite(command?.timeoutMs) ? Math.max(1, Math.floor(command.timeoutMs)) : 3e4;
-            return new Promise((resolve2, reject) => {
-              const timer = setTimeout(() => {
-                pendingActionResolutions.delete(actionRequestId);
-                resolve2(false);
-                send({
-                  type: "daemon:action_timeout",
-                  action: actionName,
-                  actionRequestId,
-                  timeoutMs
-                });
-              }, timeoutMs);
-              pendingActionResolutions.set(actionRequestId, {
-                resolve: resolve2,
-                reject,
-                timer,
-                runtimeRequestId: actionRequestId,
-                actionName
-              });
-              send({
-                type: "daemon:action_request",
-                action: actionName,
-                actionRequestId,
-                params,
-                blackboard
-              });
-            });
-          }
-        );
-        registeredActions.add(actionName);
-        send({ type: "daemon:ok", op, name: actionName });
-        break;
-      }
-      case "action:list": {
-        send({
-          type: "daemon:ok",
-          op,
-          actions: [...registeredActions],
-          pending: pendingActionResolutions.size
-        });
-        break;
-      }
-      case "action:reply": {
-        const actionRequestId = command?.actionRequestId;
-        if (typeof actionRequestId !== "string") {
-          send({ type: "daemon:error", op, error: "action:reply requires actionRequestId" });
-          break;
-        }
-        const pending = pendingActionResolutions.get(actionRequestId);
-        if (!pending) {
-          send({ type: "daemon:error", op, error: `Unknown actionRequestId: ${actionRequestId}` });
-          break;
-        }
-        clearTimeout(pending.timer);
-        pendingActionResolutions.delete(actionRequestId);
-        const status = command?.status;
-        const success = typeof command?.success === "boolean" ? command.success : status === "success" || status === "true";
-        pending.resolve(Boolean(success));
-        send({ type: "daemon:ok", op, actionRequestId, success: Boolean(success) });
-        break;
-      }
-      case "action:unregister": {
-        if (!supportsActionRegistry) {
-          send({ type: "daemon:error", op, error: "Runtime does not expose registerAction()" });
-          break;
-        }
-        const actionName = command?.name;
-        if (typeof actionName !== "string" || actionName.trim() === "") {
-          send({ type: "daemon:error", op, error: "action:unregister requires non-empty name" });
-          break;
-        }
-        runtime.registerAction(actionName, () => false);
-        registeredActions.delete(actionName);
-        send({ type: "daemon:ok", op, name: actionName });
-        break;
-      }
-      case "stop": {
-        send({ type: "daemon:stopped", reason: "command" });
-        close();
-        break;
-      }
-      default:
-        send({ type: "daemon:error", error: `Unknown op: ${String(op)}` });
-    }
-  });
-  await new Promise((resolve2) => {
-    rl.once("close", () => resolve2());
-  });
-}
-async function runScript(opts) {
-  if (!opts.file) {
-    console.error("Error: No input file specified");
-    process.exit(1);
-  }
-  const filePath = path.resolve(opts.file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Error: File not found: ${filePath}`);
-    process.exit(1);
-  }
-  const source = fs.readFileSync(filePath, "utf-8");
-  const ext = path.extname(filePath);
-  console.log(`[holoscript] Running ${path.basename(filePath)} (target: ${opts.target})`);
-  const parseResult = parse(source);
-  const ast = parseResult.ast;
-  if (opts.debug) {
-    console.log(`[holoscript] Parsed ${ast.body?.length || 0} top-level nodes`);
-    console.log(`[holoscript] File type: ${ext}`);
-  }
-  const profile = opts.profile === "headless" ? HEADLESS_PROFILE : getProfile(opts.profile);
-  const runtime = createHeadlessRuntime(ast, {
-    profile,
-    tickRate: 10,
-    debug: opts.debug,
-    hostCapabilities: createNodeHostCapabilities(path.dirname(filePath))
-  });
-  registerStdlib(
-    runtime,
-    {
-      policy: {
-        rootDir: path.dirname(filePath),
-        allowedPaths: opts.allowedPaths.length > 0 ? opts.allowedPaths : ["compositions", "data", "src", "packages"],
-        maxFileBytes: 2 * 1024 * 1024,
-        allowShell: opts.allowShell,
-        allowedShellCommands: opts.allowedShellCommands,
-        maxShellOutputBytes: 100 * 1024,
-        shellTimeoutMs: 6e4,
-        allowNetwork: opts.allowedHosts.length > 0,
-        allowedHosts: opts.allowedHosts
-      },
-      hostCapabilities: createNodeHostCapabilities(path.dirname(filePath))
-    }
-  );
-  new InteropContext(path.dirname(filePath));
-  if (opts.debug) {
-    console.log(`[holoscript] Profile: ${profile.name}`);
-    console.log(`[holoscript] Interop context: ${path.dirname(filePath)}`);
-  }
-  runtime.start();
-  if (opts.daemon) {
-    if (opts.debug) {
-      console.log("[holoscript] Entering daemon mode");
-    }
-    await runDaemon(runtime, opts);
-    return;
-  }
-  runTicks(runtime, opts.ticks);
-  runtime.stop();
-  const stats = runtime.getStats();
-  console.log(
-    `[holoscript] Complete \u2014 ${stats.tickCount} ticks, ${stats.nodesProcessed} nodes processed`
-  );
-  if (opts.watch) {
-    console.log(`[holoscript] Watching for changes... (Ctrl+C to stop)`);
-    const watcher = new HotReloadWatcher({
-      watchPaths: [path.dirname(filePath)],
-      extensions: [".hs", ".hsplus", ".holo"],
-      debounceMs: 300,
-      mode: "soft"
-    });
-    watcher.on("reload", async (event) => {
-      console.log(`
-[holoscript] File changed: ${path.basename(event.filePath)}`);
-      console.log(`[holoscript] Re-running ${path.basename(filePath)}...`);
-      try {
-        const newSource = fs.readFileSync(filePath, "utf-8");
-        const newParseResult = parse(newSource);
-        const newAst = newParseResult.ast;
-        const newRuntime = createHeadlessRuntime(newAst, {
-          profile: opts.profile === "headless" ? HEADLESS_PROFILE : getProfile(opts.profile),
-          tickRate: 10,
-          debug: opts.debug,
-          hostCapabilities: createNodeHostCapabilities(path.dirname(filePath))
-        });
-        newRuntime.start();
-        runTicks(newRuntime, opts.ticks);
-        newRuntime.stop();
-        const newStats = newRuntime.getStats();
-        console.log(
-          `[holoscript] Complete \u2014 ${newStats.tickCount} ticks, ${newStats.nodesProcessed} nodes`
-        );
-      } catch (err) {
-        console.error(`[holoscript] Error:`, err.message);
-      }
-    });
-    watcher.start();
-    await new Promise(() => {
-    });
-  }
-}
-async function testScript(opts) {
-  if (!opts.file) {
-    console.error("Error: No test file specified");
-    process.exit(1);
-  }
-  const filePath = path.resolve(opts.file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Error: File not found: ${filePath}`);
-    process.exit(1);
-  }
-  const source = fs.readFileSync(filePath, "utf-8");
-  console.log(`[holoscript test] Running tests in ${path.basename(filePath)}`);
-  const parseResult = parse(source);
-  const ast = parseResult.ast;
-  const profile = HEADLESS_PROFILE;
-  const runtime = createHeadlessRuntime(ast, { profile, tickRate: 10, debug: opts.debug });
-  runtime.start();
-  for (let i = 0; i < 50; i++) runtime.tick();
-  const runner = new ScriptTestRunner({
-    debug: opts.debug,
-    runtimeState: runtime.getState()
-  });
-  const scriptResults = runner.runTestsFromSource(source, filePath);
-  const runtimeState = runtime.getState();
-  const compositionState = Object.keys(runtimeState).length > 0 ? runtimeState : CompositionTestRunner.extractStateFromSource(source);
-  const computedDefs = CompositionTestRunner.extractComputedFromSource(source);
-  const compositionRunner = new CompositionTestRunner(compositionState, computedDefs, {
-    debug: opts.debug
-  });
-  const compositionResults = compositionRunner.runTestsFromSource(source);
-  const results = [...scriptResults, ...compositionResults];
-  const passed = results.filter((r) => r.status === "passed").length;
-  const failed = results.filter((r) => r.status === "failed").length;
-  const skipped = results.filter((r) => r.status === "skipped").length;
-  console.log("");
-  for (const result of results) {
-    const icon = result.status === "passed" ? "\u2713" : result.status === "failed" ? "\u2717" : "\u25CB";
-    const color = result.status === "passed" ? "\x1B[32m" : result.status === "failed" ? "\x1B[31m" : "\x1B[33m";
-    console.log(`  ${color}${icon}\x1B[0m ${result.name} (${result.durationMs}ms)`);
-    if (result.error) {
-      console.log(`    \x1B[31m${result.error}\x1B[0m`);
-    }
-  }
-  console.log("");
-  console.log(
-    `Tests: ${passed} passed, ${failed} failed, ${skipped} skipped (${results.length} total)`
-  );
-  if (failed > 0) process.exit(1);
-}
-function compileScript(opts) {
-  if (!opts.file) {
-    console.error("Error: No input file specified");
-    process.exit(1);
-  }
-  const filePath = path.resolve(opts.file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Error: File not found: ${filePath}`);
-    process.exit(1);
-  }
-  const source = fs.readFileSync(filePath, "utf-8");
-  if (opts.enforceGotchas) {
-    const gotchaRe = /@gotcha\s*\{([^}]+)\}/g;
-    let gMatch;
-    const criticals = [];
-    while ((gMatch = gotchaRe.exec(source)) !== null) {
-      const block = gMatch[1];
-      const sevMatch = block.match(/severity:\s*"([^"]*)"/i);
-      const severity = sevMatch?.[1] || "warning";
-      if (severity === "critical") {
-        const warnMatch = block.match(/warning:\s*"([^"]*)"/i);
-        const mitMatch = block.match(/mitigation:\s*"([^"]*)"/i);
-        criticals.push({
-          warning: warnMatch?.[1] || "Unknown critical gotcha",
-          mitigation: mitMatch?.[1] || "No mitigation specified"
-        });
-      }
-    }
-    if (criticals.length > 0) {
-      console.error(
-        `[holoscript compile] BLOCKED by ${criticals.length} critical @gotcha violation(s):`
-      );
-      for (const g of criticals) {
-        console.error(`  \u2717 ${g.warning}`);
-        console.error(`    mitigation: ${g.mitigation}`);
-      }
-      process.exit(1);
-    }
-    console.log(`[holoscript compile] @gotcha check passed (no critical violations)`);
-  }
-  const compileResult = parse(source);
-  if (!compileResult.success) {
-    console.error(`[holoscript compile] Failed to parse: ${compileResult.errors?.[0]?.message}`);
-    process.exit(1);
-  }
-  const ast = compileResult.ast;
-  const outputPath = opts.output || filePath.replace(/\.(hs|hsplus|holo)$/, `.${opts.target === "python" ? "py" : "js"}`);
-  console.log(
-    `[holoscript compile] ${path.basename(filePath)} \u2192 ${opts.target} \u2192 ${path.basename(outputPath)}`
-  );
-  let output;
-  switch (opts.target) {
-    case "node":
-      output = generateNodeTarget(ast);
-      break;
-    case "python":
-      output = generatePythonTarget(ast);
-      break;
-    default:
-      output = JSON.stringify(ast, null, 2);
-  }
-  fs.writeFileSync(outputPath, output, "utf-8");
-  console.log(`[holoscript compile] Written to ${outputPath}`);
-}
-function generateNodeTarget(ast) {
-  const lines = [
-    "// Auto-generated by holoscript compile --target node",
-    "// Source: HoloScript composition",
-    `"use strict";`,
-    ""
-  ];
-  if (ast.root && ast.root.children) {
-    for (const node of ast.root.children) {
-      if (node.type === "composition" || node.type === "ObjectDeclaration") {
-        const name = node.name || "default";
-        lines.push(`// ${node.type}: ${name}`);
-        lines.push(`module.exports.${name} = ${JSON.stringify(node, null, 2)};`);
-        lines.push("");
-      }
-    }
-  }
-  return lines.join("\n");
-}
-function generatePythonTarget(ast) {
-  const lines = [
-    "# Auto-generated by holoscript compile --target python",
-    "# Source: HoloScript composition",
-    "import json",
-    ""
-  ];
-  if (ast.root && ast.root.children) {
-    for (const node of ast.root.children) {
-      if (node.type === "composition" || node.type === "ObjectDeclaration") {
-        const name = node.name || "default_obj";
-        lines.push(`# ${node.type}: ${name}`);
-        lines.push(`${name} = json.loads('''${JSON.stringify(node)}''')`);
-        lines.push("");
-      }
-    }
-  }
-  return lines.join("\n");
-}
-async function deployScript(opts) {
-  if (!opts.file) {
-    console.error("Error: No source file specified");
-    console.error(
-      "Usage: holoscript deploy <file> [--share] [--publish] [--price <eth>] [--mint-nft] [--author <name>] [--license <type>] [--server <url>]"
-    );
-    process.exit(1);
-  }
-  const filePath = path.resolve(opts.file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Error: File not found: ${filePath}`);
-    process.exit(1);
-  }
-  const source = fs.readFileSync(filePath, "utf-8");
-  const fileName = path.basename(filePath);
-  const title = path.basename(filePath, path.extname(filePath));
-  console.log(`Parsing ${fileName}...`);
-  const ast = parse(source);
-  if (ast.errors && ast.errors.length > 0) {
-    console.error("Parse errors:");
-    for (const err of ast.errors) {
-      console.error(`  ${err.message || err}`);
-    }
-    process.exit(1);
-  }
-  const license = opts.license || "free";
-  const provenance = generateProvenance(source, ast, {
-    author: opts.author || "anonymous",
-    license
-  });
-  console.log(
-    `Provenance: ${provenance.publishMode} | hash: ${provenance.hash.slice(0, 12)}... | license: ${provenance.license}`
-  );
-  if (provenance.imports.length > 0) {
-    const importedLicenses = provenance.imports.map((imp) => ({
-      path: imp.path,
-      license: "free"
-    }));
-    const licenseCheck = checkLicenseCompatibility(license, importedLicenses);
-    if (licenseCheck.warnings.length > 0) {
-      for (const w of licenseCheck.warnings) {
-        console.log(`  Warning: ${w}`);
-      }
-    }
-    if (!licenseCheck.compatible) {
-      console.error("License compatibility errors:");
-      for (const e of licenseCheck.errors) {
-        console.error(`  ${e}`);
-      }
-      process.exit(1);
-    }
-    if (licenseCheck.forcedLicense) {
-      console.log(`  License forced to "${licenseCheck.forcedLicense}" by imports`);
-    }
-  }
-  const serverUrl = opts.serverUrl.replace(/\/$/, "");
-  if (opts.publish) {
-    const priceWei = ethToWei(opts.price || "0");
-    const importChain = provenance.imports.map((imp, i) => ({
-      contentHash: imp.hash || `import-${i}`,
-      author: imp.author || imp.path,
-      depth: 1,
-      children: []
-    }));
-    const revenuePreview = calculateRevenueDistribution(
-      priceWei,
-      provenance.author || "anonymous",
-      importChain
-    );
-    console.log("\nRevenue distribution:");
-    for (const line of formatRevenueDistribution(revenuePreview)) {
-      console.log(`  ${line}`);
-    }
-    console.log(`
-Publishing to protocol at ${serverUrl}...`);
-    const metadataBody = JSON.stringify({
-      contentHash: provenance.hash,
-      provenance: {
-        hash: provenance.hash,
-        author: provenance.author,
-        license: provenance.license,
-        publishMode: provenance.publishMode,
-        imports: provenance.imports,
-        created: provenance.created
-      }
-    });
-    try {
-      const metaRes = await fetch(`${serverUrl}/api/protocol/metadata`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: metadataBody
-      });
-      if (!metaRes.ok) {
-        const text = await metaRes.text();
-        console.error(`Metadata storage failed (${metaRes.status}): ${text}`);
-        process.exit(1);
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`Metadata storage failed: ${msg}`);
-      process.exit(1);
-    }
-    const protocolBody = JSON.stringify({
-      contentHash: provenance.hash,
-      author: provenance.author || "anonymous",
-      importHashes: provenance.imports.map((imp) => imp.hash).filter(Boolean),
-      license: provenance.license,
-      publishMode: provenance.publishMode,
-      price: opts.price || "0",
-      referralBps: PROTOCOL_CONSTANTS.DEFAULT_REFERRAL_BPS,
-      metadataURI: `${serverUrl}/metadata/${provenance.hash}`,
-      mintAsNFT: opts.mintNft,
-      // Include scene data for CDN deploy
-      code: source,
-      title,
-      description: `Published from CLI: ${fileName}`
-    });
-    try {
-      const pubRes = await fetch(`${serverUrl}/api/protocol`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: protocolBody
-      });
-      if (!pubRes.ok) {
-        const text = await pubRes.text();
-        console.error(`Protocol publish failed (${pubRes.status}): ${text}`);
-        process.exit(1);
-      }
-      const pubResult = await pubRes.json();
-      console.log("\nPublished to HoloScript Protocol!");
-      console.log(`  Hash:     ${pubResult.contentHash}`);
-      console.log(`  ID:       ${pubResult.protocolId}`);
-      console.log(`  Collect:  ${pubResult.collectUrl}`);
-      console.log(`  Registry: ${pubResult.registryUrl}`);
-      if (pubResult.sceneUrl) {
-        console.log(`  Scene:    ${pubResult.sceneUrl}`);
-      }
-      if (pubResult.embedUrl) {
-        console.log(`  Embed:    ${pubResult.embedUrl}`);
-      }
-      if (priceWei > 0n) {
-        console.log(`  Price:    ${opts.price} ETH`);
-      } else {
-        console.log("  Price:    Free collect");
-      }
-      if (opts.mintNft) {
-        console.log("  NFT:      Zora mint requested");
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`Protocol publish failed: ${msg}`);
-      console.error(
-        "Is the server running? Try: holoscript deploy <file> --publish --server http://localhost:3000"
-      );
-      process.exit(1);
-    }
-    return;
-  }
-  const endpoint = `${serverUrl}/api/deploy`;
-  console.log(`Deploying to ${serverUrl}...`);
-  const body = JSON.stringify({
-    code: source,
-    title,
-    description: `Deployed from CLI: ${fileName}`,
-    author: provenance.author,
-    license: provenance.license,
-    provenance: {
-      hash: provenance.hash,
-      publishMode: provenance.publishMode,
-      imports: provenance.imports
-    }
-  });
-  try {
-    const res = await fetch(endpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      console.error(`Deploy failed (${res.status}): ${text}`);
-      process.exit(1);
-    }
-    const result = await res.json();
-    console.log("\nDeployed successfully!");
-    console.log(`  ID:    ${result.id}`);
-    console.log(`  URL:   ${result.url}`);
-    console.log(`  Embed: ${result.embed}`);
-    console.log(`  API:   ${result.api}`);
-    if (result.provenance) {
-      console.log(`  Mode:  ${result.provenance.publishMode}`);
-      console.log(`  Hash:  ${result.provenance.hash}`);
-    }
-    if (opts.share) {
-      console.log(`
-Share URL: ${result.url}`);
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`Deploy failed: ${msg}`);
-    console.error(
-      "Is the server running? Try: holoscript deploy <file> --server http://localhost:3000"
-    );
-    process.exit(1);
-  }
-}
-function absorbScript(opts) {
-  if (!opts.file) {
-    console.error("Error: No source file specified");
-    process.exit(1);
-  }
-  const filePath = path.resolve(opts.file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Error: File not found: ${filePath}`);
-    process.exit(1);
-  }
-  const content = fs.readFileSync(filePath, "utf-8");
-  const ext = path.extname(filePath).toLowerCase();
-  const langMap = {
-    ".py": "python",
-    ".ts": "typescript",
-    ".tsx": "typescript",
-    ".js": "javascript",
-    ".jsx": "javascript",
-    ".mjs": "javascript"
-  };
-  const language = langMap[ext];
-  if (!language) {
-    console.error(
-      `Error: Unsupported file type '${ext}'. Supported: .py, .ts, .tsx, .js, .jsx, .mjs`
-    );
-    process.exit(1);
-  }
-  const outputPath = opts.output || filePath.replace(/\.\w+$/, ".hsplus");
-  console.log(
-    `[holoscript absorb] ${path.basename(filePath)} (${language}) \u2192 ${path.basename(outputPath)}`
-  );
-  const processor = new AbsorbProcessor();
-  const result = processor.absorb({ language, filePath, content });
-  fs.writeFileSync(outputPath, result.generatedHSPlus, "utf-8");
-  console.log(`[holoscript absorb] Extracted:`);
-  console.log(`  ${result.functions.length} functions`);
-  console.log(`  ${result.classes.length} classes`);
-  console.log(`  ${result.imports.length} imports`);
-  console.log(`  ${result.constants.length} constants`);
-  if (result.warnings.length > 0) {
-    console.log(`
-  Warnings:`);
-    for (const w of result.warnings) {
-      console.log(`    \u26A0 ${w}`);
-    }
-  }
-  console.log(`[holoscript absorb] Written to ${outputPath}`);
-}
-function findGitRoot(startDir) {
-  let dir = startDir;
-  while (dir !== path.dirname(dir)) {
-    if (fs.existsSync(path.join(dir, ".git"))) return dir;
-    dir = path.dirname(dir);
-  }
-  return startDir;
-}
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-function extractEconomyConfig(ast) {
-  const result = {};
-  let found = false;
-  function walk(node) {
-    if (!node || typeof node !== "object") return;
-    const obj = node;
-    if (Array.isArray(obj.traits)) {
-      for (const trait of obj.traits) {
-        const t = trait;
-        if (t.name === "economy" && typeof t.config === "object" && t.config) {
-          const cfg = t.config;
-          if (typeof cfg.budget === "number") result.budget = cfg.budget;
-          if (typeof cfg.default_spend_limit === "number")
-            result.default_spend_limit = cfg.default_spend_limit;
-          if (typeof cfg.initial_balance === "number") result.initial_balance = cfg.initial_balance;
-          if (typeof cfg.task_completion_reward === "number")
-            result.task_completion_reward = cfg.task_completion_reward;
-          found = true;
-        }
-      }
-    }
-    if (Array.isArray(obj.directives)) {
-      for (const dir of obj.directives) {
-        const d = dir;
-        if ((d.type === "trait" || d.type === "ObjectTrait") && d.name === "economy" && typeof d.config === "object" && d.config) {
-          const cfg = d.config;
-          if (typeof cfg.budget === "number") result.budget = cfg.budget;
-          if (typeof cfg.default_spend_limit === "number")
-            result.default_spend_limit = cfg.default_spend_limit;
-          if (typeof cfg.initial_balance === "number") result.initial_balance = cfg.initial_balance;
-          if (typeof cfg.task_completion_reward === "number")
-            result.task_completion_reward = cfg.task_completion_reward;
-          found = true;
-        }
-      }
-    }
-    if (Array.isArray(obj.body)) obj.body.forEach(walk);
-    if (Array.isArray(obj.children)) obj.children.forEach(walk);
-    if (Array.isArray(obj.objects)) obj.objects.forEach(walk);
-  }
-  walk(ast);
-  return found ? result : void 0;
-}
-function loadRuntimeSkillActions(skillsDir, opts, host, repoRoot, debug = false) {
-  const actions = {};
-  if (!fs.existsSync(skillsDir)) return actions;
-  const files = fs.readdirSync(skillsDir).filter((name) => name.endsWith(".hsplus")).map((name) => path.join(skillsDir, name));
-  for (const file of files) {
-    const content = fs.readFileSync(file, "utf-8");
-    const actionRe = /action\s+"([^"]+)"\s*\{([\s\S]*?)\}/g;
-    let match;
-    while ((match = actionRe.exec(content)) !== null) {
-      const actionName = match[1].trim();
-      const block = match[2];
-      const commandMatch = block.match(/command\s*:\s*["']([^"']+)["']/);
-      if (!commandMatch) continue;
-      const command = commandMatch[1].trim();
-      const argMatch = block.match(/args\s*:\s*\[([^\]]*)\]/);
-      const bakedArgs = [];
-      if (argMatch) {
-        const argValueRe = /["']([^"']+)["']/g;
-        let argToken;
-        while ((argToken = argValueRe.exec(argMatch[1])) !== null) {
-          bakedArgs.push(argToken[1]);
-        }
-      }
-      actions[actionName] = async (params, bb, ctx) => {
-        if (!opts.allowShell) {
-          bb.skill_error = `Skill ${actionName} blocked: shell disabled`;
-          return false;
-        }
-        if (opts.allowedShellCommands.length > 0) {
-          const executable = command.split(/\s+/)[0].toLowerCase();
-          const allowed = opts.allowedShellCommands.some((c) => c.toLowerCase() === executable);
-          if (!allowed) {
-            bb.skill_error = `Skill ${actionName} blocked: command ${executable} not allowlisted`;
-            return false;
-          }
-        }
-        const runtimeArgs = Array.isArray(params.args) ? params.args.filter((v) => typeof v === "string") : [];
-        const timeoutMs = typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs) ? Math.max(1e3, Math.min(3e5, Math.floor(params.timeoutMs))) : 6e4;
-        const result = await host.exec(command, [...bakedArgs, ...runtimeArgs], {
-          cwd: repoRoot,
-          timeoutMs
-        });
-        bb.skill_last_action = actionName;
-        bb.skill_last_code = result.code ?? -1;
-        bb.skill_last_stdout = result.stdout.slice(0, 5e4);
-        bb.skill_last_stderr = result.stderr.slice(0, 5e4);
-        ctx.emit("daemon:skill:executed", { actionName, code: result.code, file });
-        return result.code === 0;
-      };
-    }
-  }
-  if (debug) {
-    console.log(
-      `[daemon] Loaded ${Object.keys(actions).length} runtime skill action(s) from ${skillsDir}`
-    );
-  }
-  return actions;
-}
-async function daemonScript(opts) {
-  if (!opts.file) {
-    console.error("Error: No composition file specified");
-    process.exit(1);
-  }
-  const filePath = path.resolve(opts.file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Error: File not found: ${filePath}`);
-    process.exit(1);
-  }
-  const { createDaemonActions, getDaemonFileState } = await import('@holoscript/absorb-service/daemon');
-  const repoRoot = findGitRoot(path.dirname(filePath));
-  const source = fs.readFileSync(filePath, "utf-8");
-  const parseResult = parse(source);
-  if (!parseResult.success || !parseResult.ast) {
-    const errors = parseResult.errors?.map((e) => e.message).join(", ") || "unknown";
-    console.error(`[daemon] Parse failed: ${errors}`);
-    process.exit(1);
-  }
-  const compositionAST = parseResult.ast;
-  console.log(`[daemon] Composition: ${path.basename(filePath)}`);
-  console.log(`[daemon] Repo root: ${repoRoot}`);
-  console.log(
-    `[daemon] Cycles: ${opts.cycles} | Commit: ${opts.commit} | Timeout: ${opts.timeout}min | Provider: ${opts.provider} | Model: ${opts.model} | Tool profile: ${opts.toolProfile} | Always-on: ${opts.alwaysOn} | Cycle interval: ${opts.cycleIntervalSec}s`
-  );
-  const stateDir = path.join(repoRoot, ".holoscript");
-  if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
-  const lockFile = path.join(stateDir, "daemon.lock");
-  const lockData = { pid: process.pid, time: Date.now(), heartbeat: Date.now() };
-  if (fs.existsSync(lockFile)) {
-    try {
-      const existing = JSON.parse(fs.readFileSync(lockFile, "utf-8"));
-      const staleMs = 12e4;
-      if (Date.now() - existing.heartbeat < staleMs) {
-        console.error(
-          `[daemon] Another daemon is running (PID ${existing.pid}). Remove ${lockFile} to force.`
-        );
-        process.exit(1);
-      }
-      console.log(`[daemon] Reclaiming stale lock from PID ${existing.pid}`);
-    } catch {
-    }
-  }
-  fs.writeFileSync(lockFile, JSON.stringify(lockData), "utf-8");
-  const heartbeatTimer = setInterval(() => {
-    try {
-      fs.writeFileSync(lockFile, JSON.stringify({ ...lockData, heartbeat: Date.now() }), "utf-8");
-    } catch {
-    }
-  }, 3e4);
-  const fileWatchers = [];
-  const cleanup = () => {
-    clearInterval(heartbeatTimer);
-    for (const watcher of fileWatchers) {
-      try {
-        watcher.close();
-      } catch {
-      }
-    }
-    try {
-      fs.rmSync(lockFile, { force: true });
-    } catch {
-    }
-  };
-  process.once("SIGINT", cleanup);
-  process.once("SIGTERM", cleanup);
-  process.once("uncaughtException", (err) => {
-    cleanup();
-    console.error("[daemon] Uncaught:", err);
-    process.exit(1);
-  });
-  process.once("unhandledRejection", (err) => {
-    cleanup();
-    console.error("[daemon] Unhandled:", err);
-    process.exit(1);
-  });
-  const host = {
-    readFile: (p) => fs.readFileSync(path.resolve(repoRoot, p), "utf-8"),
-    writeFile: (p, c) => {
-      const resolved = path.resolve(repoRoot, p);
-      fs.mkdirSync(path.dirname(resolved), { recursive: true });
-      fs.writeFileSync(resolved, c, "utf-8");
-    },
-    exists: (p) => fs.existsSync(path.resolve(repoRoot, p)),
-    exec: (cmd, args = [], execOpts = {}) => new Promise((resolve2, reject) => {
-      const child = spawn(cmd, args, {
-        cwd: execOpts.cwd ?? repoRoot,
-        shell: true,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-      let stdout = "";
-      let stderr = "";
-      let timer = null;
-      child.stdout?.on("data", (d) => {
-        stdout += d.toString("utf-8");
-      });
-      child.stderr?.on("data", (d) => {
-        stderr += d.toString("utf-8");
-      });
-      if (execOpts.timeoutMs && execOpts.timeoutMs > 0) {
-        timer = setTimeout(() => {
-          try {
-            child.kill("SIGKILL");
-          } catch {
-          }
-        }, execOpts.timeoutMs);
-      }
-      child.on("close", (code) => {
-        if (timer) clearTimeout(timer);
-        resolve2({ code, stdout, stderr });
-      });
-      child.on("error", reject);
-    })
-  };
-  const skillsDirRel = opts.skillsDir || "compositions/skills";
-  const skillsDirAbs = path.resolve(repoRoot, skillsDirRel);
-  if (!fs.existsSync(skillsDirAbs)) {
-    fs.mkdirSync(skillsDirAbs, { recursive: true });
-  }
-  let runtimeSkillActions = loadRuntimeSkillActions(skillsDirAbs, opts, host, repoRoot, opts.debug);
-  let activeRuntime = null;
-  const reloadRuntimeSkills = () => {
-    runtimeSkillActions = loadRuntimeSkillActions(skillsDirAbs, opts, host, repoRoot, opts.debug);
-    if (activeRuntime) {
-      for (const [name, handler] of Object.entries(runtimeSkillActions)) {
-        activeRuntime.registerAction(name, handler);
-      }
-    }
-  };
-  try {
-    const watcher = fs.watch(skillsDirAbs, { persistent: false }, () => {
-      reloadRuntimeSkills();
-    });
-    fileWatchers.push(watcher);
-  } catch (error) {
-    if (opts.debug) {
-      console.warn(
-        `[daemon] Skill watcher unavailable for ${skillsDirAbs}: ${error.message}`
-      );
-    }
-  }
-  const llm = createDaemonLLMProvider(opts);
-  const defaultFocusRotation = [
-    "typefix",
-    "coverage",
-    "typefix",
-    "lint",
-    "target-sweep",
-    "trait-sampling",
-    "runtime-matrix",
-    "absorb-roundtrip",
-    "typefix",
-    "all"
-  ];
-  const focusRotation = getASTBlackboardValue(compositionAST, "focus_rotation") ?? defaultFocusRotation;
-  const providerRotationEnabled = getASTBlackboardValue(compositionAST, "provider_rotation_enabled") ?? opts.providerRotation;
-  const rotationProviders = getASTBlackboardValue(compositionAST, "provider_rotation") ?? ["anthropic", "xai"];
-  const quarantineThreshold = getASTBlackboardValue(compositionAST, "quarantine_threshold") ?? 3;
-  const economyConfig = extractEconomyConfig(compositionAST);
-  if (economyConfig && opts.debug) {
-    console.log(`[daemon] Economy config from composition:`, economyConfig);
-  }
-  const config = {
-    repoRoot,
-    commit: opts.commit,
-    model: opts.model,
-    provider: opts.provider,
-    toolProfile: opts.toolProfile,
-    verbose: opts.debug,
-    trial: opts.trial,
-    focusRotation,
-    stateDir,
-    quarantineThreshold,
-    skillsDir: opts.skillsDir,
-    toolPolicy: {
-      allowShell: opts.allowShell,
-      allowedShellCommands: opts.allowedShellCommands,
-      allowedHosts: opts.allowedHosts,
-      allowedPaths: opts.allowedPaths
-    },
-    economyConfig,
-    sessionId: opts.sessionId
-  };
-  const stateFile = path.join(stateDir, "daemon-state.json");
-  const telemetryFile = path.join(stateDir, "daemon-telemetry.jsonl");
-  const daemonStateDefaults = {
-    totalCycles: 0,
-    focusIndex: 0,
-    bestQuality: 0,
-    lastQuality: 0,
-    totalCostUSD: 0,
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    typeErrorBaseline: 0,
-    lastFocus: "",
-    lastCycleTimeISO: ""
-  };
-  let daemonState = { ...daemonStateDefaults };
-  if (fs.existsSync(stateFile)) {
-    try {
-      daemonState = { ...daemonState, ...JSON.parse(fs.readFileSync(stateFile, "utf-8")) };
-    } catch {
-    }
-  }
-  const fileStateFile = path.join(stateDir, "daemon-file-state.json");
-  if (fs.existsSync(fileStateFile)) {
-    try {
-      const fileState = JSON.parse(fs.readFileSync(fileStateFile, "utf-8"));
-      config.committedFiles = fileState.committed || [];
-      config.failedFiles = fileState.failures || {};
-    } catch {
-    }
-  }
-  if (daemonState.typeErrorBaseline > 0) {
-    config.typeErrorBaseline = daemonState.typeErrorBaseline;
-  }
-  let daemonResult = createDaemonActions(host, llm, config);
-  let actions = daemonResult.actions;
-  try {
-    await llm.chat({ system: "reply ok", prompt: "ok", maxTokens: 1 });
-    console.log("[daemon] API key validated");
-  } catch (err) {
-    console.error(`[daemon] API key validation failed: ${err.message}`);
-    cleanup();
-    process.exit(1);
-  }
-  let convergenceStreak = 0;
-  const CONVERGENCE_THRESHOLD = 3;
-  let cycle = 0;
-  while (opts.alwaysOn || cycle < opts.cycles) {
-    let focusIdx = daemonState.focusIndex % focusRotation.length;
-    let focus = opts.focus || focusRotation[focusIdx];
-    if (!opts.focus) {
-      const wisdomFile = path.join(stateDir, "accumulated-wisdom.json");
-      let wisdomEntries = [];
-      try {
-        if (fs.existsSync(wisdomFile)) {
-          wisdomEntries = JSON.parse(fs.readFileSync(wisdomFile, "utf-8"));
-        }
-      } catch {
-      }
-      const STALE_THRESHOLD = 3;
-      let attempts = 0;
-      while (attempts < focusRotation.length) {
-        const focusHistory = wisdomEntries.filter((w) => w.focus === focus);
-        const lastN = focusHistory.slice(-STALE_THRESHOLD);
-        const isStale = lastN.length >= STALE_THRESHOLD && lastN.every((w) => (w.delta || 0) === 0);
-        if (!isStale) break;
-        console.log(
-          `[daemon] Skipping stale focus "${focus}" (${STALE_THRESHOLD} consecutive zero-delta cycles)`
-        );
-        focusIdx = (focusIdx + 1) % focusRotation.length;
-        focus = focusRotation[focusIdx];
-        attempts++;
-      }
-    }
-    config.cycleFocus = focus;
-    config.daemonFile = filePath;
-    config.qualityBefore = daemonState.lastQuality;
-    const cycleStart = Date.now();
-    if (providerRotationEnabled) {
-      const cycleProvider = rotationProviders[cycle % rotationProviders.length];
-      const cycleModel = defaultModelForProvider(cycleProvider);
-      const cycleToolProfile = defaultToolProfileForProvider(cycleProvider);
-      const cycleOpts = {
-        ...opts,
-        provider: cycleProvider,
-        model: cycleModel};
-      const cycleLlm = createDaemonLLMProvider(cycleOpts);
-      config.provider = cycleProvider;
-      config.model = cycleModel;
-      config.toolProfile = cycleToolProfile;
-      daemonResult = createDaemonActions(host, cycleLlm, config);
-      actions = daemonResult.actions;
-      console.log(
-        `
-[daemon] === Cycle ${cycle + 1}${opts.alwaysOn ? "" : `/${opts.cycles}`} | Focus: ${focus} | Provider: ${cycleProvider} (${cycleModel}) ===`
-      );
-    } else {
-      console.log(
-        `
-[daemon] === Cycle ${cycle + 1}${opts.alwaysOn ? "" : `/${opts.cycles}`} | Focus: ${focus} ===`
-      );
-    }
-    const cycleAST = JSON.parse(JSON.stringify(compositionAST));
-    materializeTraits(cycleAST);
-    const bbValues = {
-      focus,
-      cycleNumber: daemonState.totalCycles + cycle,
-      daemon_file: filePath,
-      quality_before: daemonState.lastQuality
-    };
-    setASTBlackboard(cycleAST, bbValues);
-    if (opts.debug) {
-      console.log(`[daemon] Blackboard injection: focus=${focus}, daemon_file=${filePath}`);
-    }
-    const runtime = createHeadlessRuntime(cycleAST, {
-      profile: HEADLESS_PROFILE,
-      tickRate: 10,
-      debug: opts.debug,
-      hostCapabilities: createNodeHostCapabilities(repoRoot)
-    });
-    activeRuntime = runtime;
-    for (const [name, handler] of Object.entries(actions)) {
-      runtime.registerAction(name, handler);
-    }
-    for (const [name, handler] of Object.entries(runtimeSkillActions)) {
-      runtime.registerAction(name, handler);
-    }
-    daemonResult.wireTraitListeners(runtime);
-    const maxWaitMs = opts.timeout * 60 * 1e3;
-    const btResult = await new Promise(
-      (resolve2) => {
-        let resolved = false;
-        const timeout = setTimeout(() => {
-          if (!resolved) {
-            resolved = true;
-            resolve2({ status: "timeout", blackboard: {} });
-          }
-        }, maxWaitMs);
-        runtime.on("bt_complete", (payload) => {
-          if (!resolved) {
-            resolved = true;
-            clearTimeout(timeout);
-            const p = payload;
-            resolve2({
-              status: p?.status || "unknown",
-              blackboard: p?.blackboard || {}
-            });
-          }
-        });
-        runtime.start();
-      }
-    );
-    const btStatus = btResult.status;
-    const btBlackboard = btResult.blackboard;
-    const durationSec = ((Date.now() - cycleStart) / 1e3).toFixed(1);
-    const stats = runtime.getStats();
-    const inputTokens = btBlackboard.inputTokens || 0;
-    const outputTokens = btBlackboard.outputTokens || 0;
-    const qualityAfter = btBlackboard.quality_after || daemonState.lastQuality;
-    const costUSD = inputTokens * 3 / 1e6 + outputTokens * 15 / 1e6;
-    const committed = btBlackboard.committed_count || 0;
-    const qualityDelta = qualityAfter - (config.qualityBefore || 0);
-    runtime.emit("daemon:cycle_raw_telemetry", {
-      focus,
-      ticks: stats.updateCount,
-      inputTokens,
-      outputTokens,
-      qualityBefore: daemonState.lastQuality,
-      qualityAfter,
-      costUSD,
-      committed: committed > 0
-    });
-    runtime.emit("daemon:raw_quality", { value: qualityAfter, focus });
-    const totalTokens = inputTokens + outputTokens;
-    const costEfficiency = costUSD > 0 ? Math.min(1, qualityAfter * totalTokens / (costUSD * 5e5)) : qualityAfter;
-    runtime.emit("feedback:update_metric", { name: "cost_efficiency", value: costEfficiency });
-    const candidateCount = Array.isArray(btBlackboard.candidates) ? btBlackboard.candidates.length : 0;
-    const emergenceRatio = candidateCount > 0 ? Math.min(1, committed / candidateCount) : 0;
-    runtime.emit("feedback:update_metric", { name: "emergence_ratio", value: emergenceRatio });
-    const wisdomCount = btBlackboard.wisdomCount || 0;
-    const regenerativeHealth = Math.min(1, wisdomCount / 200);
-    runtime.emit("feedback:update_metric", {
-      name: "regenerative_health",
-      value: regenerativeHealth
-    });
-    runtime.stop();
-    activeRuntime = null;
-    const telemetryRecord = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      cycleNumber: daemonState.totalCycles + 1,
-      focus,
-      provider: config.provider,
-      model: config.model,
-      btStatus,
-      ticks: stats.updateCount,
-      inputTokens,
-      outputTokens,
-      totalTokens,
-      costUSD,
-      qualityBefore: config.qualityBefore || 0,
-      qualityAfter,
-      qualityDelta,
-      typeErrors: btBlackboard.quality_typeErrors ?? null,
-      testsPassed: btBlackboard.quality_testsPassed ?? null,
-      testsTotal: btBlackboard.quality_testsTotal ?? null,
-      committedCount: committed,
-      candidateCount,
-      wisdomCount,
-      durationSec: Number(durationSec)
-    };
-    fs.appendFileSync(telemetryFile, `${JSON.stringify(telemetryRecord)}
-`, "utf-8");
-    console.log(
-      `[daemon] Cycle ${cycle + 1} done in ${durationSec}s | ${stats.updateCount} ticks | BT: ${btStatus} | quality: ${qualityAfter.toFixed(3)}`
-    );
-    daemonState.totalCycles++;
-    daemonState.focusIndex = (focusIdx + 1) % focusRotation.length;
-    daemonState.lastQuality = qualityAfter;
-    if (qualityAfter > daemonState.bestQuality) {
-      daemonState.bestQuality = qualityAfter;
-    }
-    daemonState.totalInputTokens += inputTokens;
-    daemonState.totalOutputTokens += outputTokens;
-    daemonState.totalCostUSD += costUSD;
-    daemonState.lastFocus = focus;
-    daemonState.lastCycleTimeISO = (/* @__PURE__ */ new Date()).toISOString();
-    const cycleTypeErrors = btBlackboard.typeErrorBaseline || btBlackboard.typeErrorCount || 0;
-    if (daemonState.typeErrorBaseline === 0 && cycleTypeErrors > 0) {
-      daemonState.typeErrorBaseline = cycleTypeErrors;
-      config.typeErrorBaseline = cycleTypeErrors;
-      console.log(`[daemon] Established type error baseline: ${cycleTypeErrors}`);
-    }
-    fs.writeFileSync(stateFile, JSON.stringify(daemonState, null, 2), "utf-8");
-    const fileState = getDaemonFileState(repoRoot);
-    fs.writeFileSync(fileStateFile, JSON.stringify(fileState, null, 2), "utf-8");
-    if (qualityDelta <= 0 && committed === 0) {
-      convergenceStreak++;
-      if (convergenceStreak >= CONVERGENCE_THRESHOLD) {
-        console.log(
-          `[daemon] Plateau detected \u2014 ${convergenceStreak} consecutive zero-delta cycles. Escalating strategy.`
-        );
-        convergenceStreak = 0;
-        const oldThreshold = config.quarantineThreshold || 3;
-        config.quarantineThreshold = oldThreshold + 2;
-        console.log(
-          `[daemon] Raised quarantine threshold: ${oldThreshold} \u2192 ${config.quarantineThreshold}`
-        );
-        if (!opts.focus) {
-          const typefixIdx = focusRotation.indexOf("typefix");
-          if (typefixIdx >= 0) {
-            daemonState.focusIndex = typefixIdx;
-            console.log(`[daemon] Forcing next cycle to 'typefix' focus`);
-          }
-        }
-        if (config.quarantineThreshold >= quarantineThreshold + 4) {
-          console.log(
-            `[daemon] Escalated twice with no progress. Stopping to avoid wasting tokens.`
-          );
-          break;
-        }
-      }
-    } else {
-      convergenceStreak = 0;
-    }
-    cycle++;
-    if (opts.alwaysOn && opts.cycleIntervalSec > 0) {
-      console.log(`[daemon] Sleeping ${opts.cycleIntervalSec}s before next cycle...`);
-      await sleep(opts.cycleIntervalSec * 1e3);
-    }
-  }
-  cleanup();
-  console.log(`
-[daemon] Completed ${cycle} cycle(s).`);
-  console.log(
-    `[daemon] Best quality: ${daemonState.bestQuality.toFixed(3)} | Total cost: $${daemonState.totalCostUSD.toFixed(3)} | Total cycles: ${daemonState.totalCycles}`
-  );
-}
-function materializeTraits(ast) {
-  const walk = (node) => {
-    if (!node || typeof node !== "object") return;
-    const n = node;
-    const traits = /* @__PURE__ */ new Map();
-    if (Array.isArray(n.directives)) {
-      for (const directive of n.directives) {
-        const d = directive;
-        if (d.type === "trait" && typeof d.name === "string") {
-          traits.set(d.name, d.config ?? {});
-        }
-      }
-    }
-    if (traits.size > 0) {
-      n.traits = traits;
-    } else if (n.traits && !(n.traits instanceof Map)) {
-      delete n.traits;
-    }
-    for (const key of ["body", "children", "nodes", "members"]) {
-      if (Array.isArray(n[key])) {
-        n[key].forEach(walk);
-      }
-    }
-    if (n.root && typeof n.root === "object") {
-      walk(n.root);
-    }
-  };
-  walk(ast);
-}
-function setASTBlackboard(ast, values) {
-  const visited = /* @__PURE__ */ new WeakSet();
-  let found = false;
-  const walk = (node) => {
-    if (found || !node || typeof node !== "object") return;
-    const obj = node;
-    if (visited.has(obj)) return;
-    visited.add(obj);
-    if (obj.blackboard && typeof obj.blackboard === "object" && !Array.isArray(obj.blackboard)) {
-      Object.assign(obj.blackboard, values);
-      found = true;
-      return;
-    }
-    for (const key of Object.keys(obj)) {
-      const val = obj[key];
-      if (val && typeof val === "object") {
-        if (Array.isArray(val)) {
-          for (const item of val) walk(item);
-        } else if (val instanceof Map) {
-          for (const v of val.values()) walk(v);
-        } else {
-          walk(val);
-        }
-      }
-      if (found) return;
-    }
-  };
-  walk(ast);
-}
-function getASTBlackboardValue(ast, key) {
-  const visited = /* @__PURE__ */ new WeakSet();
-  let result = void 0;
-  const walk = (node) => {
-    if (result !== void 0 || !node || typeof node !== "object") return;
-    const obj = node;
-    if (visited.has(obj)) return;
-    visited.add(obj);
-    if (obj.blackboard && typeof obj.blackboard === "object" && !Array.isArray(obj.blackboard)) {
-      const bb = obj.blackboard;
-      if (key in bb) {
-        result = bb[key];
-        return;
-      }
-    }
-    for (const k of Object.keys(obj)) {
-      const val = obj[k];
-      if (val && typeof val === "object") {
-        if (Array.isArray(val)) {
-          for (const item of val) walk(item);
-        } else if (!(val instanceof Map)) {
-          walk(val);
-        }
-      }
-      if (result !== void 0) return;
-    }
-  };
-  walk(ast);
-  return result;
-}
-async function holoMeshDaemonScript(opts) {
-  if (!opts.file) {
-    console.error("Error: No composition file specified");
-    console.error("Usage: holoscript holomesh-daemon compositions/holomesh-agent.hsplus [options]");
-    process.exit(1);
-  }
-  const filePath = path.resolve(opts.file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Error: File not found: ${filePath}`);
-    process.exit(1);
-  }
-  if (!process.env.MCP_API_KEY) {
-    console.error("[holomesh-daemon] MCP_API_KEY environment variable is required");
-    process.exit(1);
-  }
-  const rawSource = fs.readFileSync(filePath, "utf-8");
-  const source = rawSource.replace(/^#(version|target|mode)\s+.*/gm, "");
-  const parseResult = parse(source);
-  if (!parseResult.success || !parseResult.ast) {
-    const errors = parseResult.errors?.map((e) => e.message).join(", ") || "unknown";
-    console.error(`[holomesh-daemon] Parse failed: ${errors}`);
-    process.exit(1);
-  }
-  const compositionAST = parseResult.ast;
-  const stateDir = path.resolve(path.dirname(filePath), ".holoscript");
-  if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
-  const stateFile = path.join(stateDir, "holomesh-state.json");
-  console.log(`[holomesh-daemon] Composition: ${path.basename(filePath)}`);
-  console.log(`[holomesh-daemon] Cycles: ${opts.cycles} | Always-on: ${opts.alwaysOn}`);
-  const lockFile = path.join(stateDir, "holomesh-daemon.lock");
-  const lockData = { pid: process.pid, time: Date.now(), heartbeat: Date.now() };
-  if (fs.existsSync(lockFile)) {
-    try {
-      const existing = JSON.parse(fs.readFileSync(lockFile, "utf-8"));
-      if (Date.now() - existing.heartbeat < 12e4) {
-        console.error(
-          `[holomesh-daemon] Another daemon is running (PID ${existing.pid}). Remove ${lockFile} to force.`
-        );
-        process.exit(1);
-      }
-      console.log(`[holomesh-daemon] Reclaiming stale lock from PID ${existing.pid}`);
-    } catch {
-    }
-  }
-  fs.writeFileSync(lockFile, JSON.stringify(lockData), "utf-8");
-  const heartbeatTimer = setInterval(() => {
-    try {
-      fs.writeFileSync(lockFile, JSON.stringify({ ...lockData, heartbeat: Date.now() }), "utf-8");
-    } catch {
-    }
-  }, 3e4);
-  const cleanup = () => {
-    clearInterval(heartbeatTimer);
-    try {
-      fs.rmSync(lockFile, { force: true });
-    } catch {
-    }
-  };
-  process.once("SIGINT", cleanup);
-  process.once("SIGTERM", cleanup);
-  let createHoloMeshDaemonActions;
-  let HoloMeshOrchestratorClient;
-  try {
-    let actionsModule;
-    let clientModule;
-    try {
-      actionsModule = await import('@holoscript/mcp-server/holomesh/agent/holomesh-daemon-actions');
-      clientModule = await import('@holoscript/mcp-server/holomesh/orchestrator-client');
-    } catch {
-      const actionsPath = "../../../mcp-server/src/holomesh/agent/holomesh-daemon-actions";
-      const clientPath = "../../../mcp-server/src/holomesh/orchestrator-client";
-      actionsModule = await import(actionsPath);
-      clientModule = await import(clientPath);
-    }
-    createHoloMeshDaemonActions = actionsModule.createHoloMeshDaemonActions;
-    HoloMeshOrchestratorClient = clientModule.HoloMeshOrchestratorClient;
-  } catch (err) {
-    console.error(`[holomesh-daemon] Failed to import holomesh modules: ${err.message}`);
-    console.error("[holomesh-daemon] Ensure @holoscript/mcp-server is installed");
-    cleanup();
-    process.exit(1);
-  }
-  const meshConfig = {
-    orchestratorUrl: process.env.MCP_ORCHESTRATOR_URL || "https://mcp-orchestrator-production-45f9.up.railway.app",
-    apiKey: process.env.MCP_API_KEY,
-    workspace: process.env.HOLOMESH_WORKSPACE || "ai-ecosystem",
-    agentName: process.env.HOLOMESH_AGENT_NAME || "holomesh-agent",
-    discoveryIntervalMs: 5 * 60 * 1e3,
-    inboxIntervalMs: 60 * 1e3,
-    maxContributionsPerCycle: 5,
-    maxQueriesPerCycle: 3,
-    budgetCapUSD: parseFloat(process.env.HOLOMESH_BUDGET_CAP || "5")
-  };
-  const client = new HoloMeshOrchestratorClient(meshConfig);
-  const v2Enabled = process.env.HOLOMESH_V2_ENABLED === "true";
-  const localAgentDid = process.env.HOLOMESH_AGENT_DID || (v2Enabled ? `did:holo:${meshConfig.agentName}` : void 0);
-  const walletEnabled = process.env.HOLOMESH_WALLET_ENABLED === "true";
-  const walletTestnet = process.env.HOLOMESH_WALLET_TESTNET === "true";
-  const { actions, wireTraitListeners } = createHoloMeshDaemonActions(client, {
-    stateFile,
-    verbose: opts.debug,
-    v2Enabled,
-    localAgentDid,
-    localMcpUrl: process.env.HOLOMESH_LOCAL_MCP_URL || "https://mcp.holoscript.net",
-    crdtSnapshotPath: v2Enabled ? path.join(path.dirname(stateFile), "holomesh-crdt.bin") : void 0,
-    peerStorePath: v2Enabled ? path.join(path.dirname(stateFile), "holomesh-peers.json") : void 0,
-    walletEnabled,
-    walletTestnet
-  });
-  console.log(
-    `[holomesh-daemon] ${Object.keys(actions).length} action handlers registered${v2Enabled ? ` (V2 P2P enabled, DID: ${localAgentDid})` : ""}${walletEnabled ? " (V3 Wallet enabled)" : ""}`
-  );
-  let cycle = 0;
-  while (opts.alwaysOn || cycle < opts.cycles) {
-    console.log(
-      `
-[holomesh-daemon] === Cycle ${cycle + 1}${opts.alwaysOn ? "" : `/${opts.cycles}`} ===`
-    );
-    const cycleAST = JSON.parse(JSON.stringify(compositionAST));
-    materializeTraits(cycleAST);
-    const runtime = createHeadlessRuntime(cycleAST, {
-      profile: HEADLESS_PROFILE,
-      tickRate: 1,
-      debug: opts.debug,
-      hostCapabilities: createNodeHostCapabilities(path.dirname(filePath))
-    });
-    for (const [name, handler] of Object.entries(actions)) {
-      runtime.registerAction(name, handler);
-    }
-    wireTraitListeners(runtime);
-    const maxWaitMs = (opts.timeout ?? 5) * 60 * 1e3;
-    const btResult = await new Promise((resolve2) => {
-      let resolved = false;
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          resolve2({ status: "timeout" });
-        }
-      }, maxWaitMs);
-      runtime.on("bt_complete", () => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timeout);
-          resolve2({ status: "complete" });
-        }
-      });
-      runtime.start();
-    });
-    runtime.stop();
-    console.log(`[holomesh-daemon] Cycle ${cycle + 1} ${btResult.status}`);
-    cycle++;
-    if (opts.alwaysOn || cycle < opts.cycles) {
-      const intervalSec = opts.cycleIntervalSec > 0 ? opts.cycleIntervalSec : 120;
-      const jitter = 1 + (Math.random() * 2 - 1) * 0.3;
-      const waitMs = Math.round(intervalSec * 1e3 * jitter);
-      console.log(`[holomesh-daemon] Waiting ${Math.round(waitMs / 1e3)}s before next cycle...`);
-      await new Promise((r) => setTimeout(r, waitMs));
-    }
-  }
-  cleanup();
-  console.log("[holomesh-daemon] Done");
-}
-async function daemonStatus(jsonOutput = false) {
-  const repoRoot = findGitRoot(process.cwd());
-  const stateDir = path.join(repoRoot, ".holoscript");
-  if (!fs.existsSync(stateDir)) {
-    if (jsonOutput) {
-      console.log(
-        JSON.stringify({
-          status: "missing_state_dir",
-          running: false,
-          stateDir
-        })
-      );
-    } else {
-      console.log("[daemon status] No state directory found. Run a daemon cycle first.");
-    }
-    return;
-  }
-  const lockFile = path.join(stateDir, "daemon.lock");
-  let isRunning = false;
-  let lockPid = 0;
-  let lastHeartbeat = 0;
-  if (fs.existsSync(lockFile)) {
-    try {
-      const lock = JSON.parse(fs.readFileSync(lockFile, "utf-8"));
-      lockPid = lock.pid;
-      lastHeartbeat = lock.heartbeat;
-      isRunning = Date.now() - lastHeartbeat < 12e4;
-    } catch {
-    }
-  }
-  const stateFile = path.join(stateDir, "daemon-state.json");
-  let ds = {};
-  if (fs.existsSync(stateFile)) {
-    try {
-      ds = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
-    } catch {
-    }
-  }
-  const fileStateFile = path.join(stateDir, "daemon-file-state.json");
-  let fileState = {
-    committed: [],
-    failures: {}
-  };
-  if (fs.existsSync(fileStateFile)) {
-    try {
-      fileState = JSON.parse(fs.readFileSync(fileStateFile, "utf-8"));
-    } catch {
-    }
-  }
-  const wisdomFile = path.join(stateDir, "accumulated-wisdom.json");
-  let wisdomCount = 0;
-  if (fs.existsSync(wisdomFile)) {
-    try {
-      wisdomCount = JSON.parse(fs.readFileSync(wisdomFile, "utf-8")).length;
-    } catch {
-    }
-  }
-  const ledgerFile = path.join(stateDir, "fix-ledger.json");
-  let ledger = [];
-  if (fs.existsSync(ledgerFile)) {
-    try {
-      ledger = JSON.parse(fs.readFileSync(ledgerFile, "utf-8"));
-    } catch {
-    }
-  }
-  const telemetryFile = path.join(stateDir, "daemon-telemetry.jsonl");
-  let telemetryCount = 0;
-  let lastTelemetry;
-  if (fs.existsSync(telemetryFile)) {
-    try {
-      const lines = fs.readFileSync(telemetryFile, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-      telemetryCount = lines.length;
-      if (lines.length > 0) {
-        lastTelemetry = JSON.parse(lines[lines.length - 1]);
-      }
-    } catch {
-    }
-  }
-  const totalCycles = ds.totalCycles || 0;
-  const lastFocus = ds.lastFocus || "n/a";
-  const lastCycleTime = ds.lastCycleTimeISO ? new Date(ds.lastCycleTimeISO).toLocaleString() : "never";
-  const bestQ = Number(ds.bestQuality || 0).toFixed(3);
-  const lastQ = Number(ds.lastQuality || 0).toFixed(3);
-  const baseline = ds.typeErrorBaseline ? `${ds.typeErrorBaseline} type errors` : "not yet measured";
-  const totalCost = Number(ds.totalCostUSD || 0);
-  const tokIn = Number(ds.totalInputTokens || 0);
-  const tokOut = Number(ds.totalOutputTokens || 0);
-  const quarantined = Object.values(fileState.failures).filter((n) => n >= 3).length;
-  if (jsonOutput) {
-    console.log(
-      JSON.stringify({
-        status: "ok",
-        running: isRunning,
-        pid: lockPid || null,
-        heartbeatAgeSec: lastHeartbeat > 0 ? Math.round((Date.now() - lastHeartbeat) / 1e3) : null,
-        stateDir,
-        session: {
-          totalCycles,
-          lastFocus,
-          lastCycleTimeISO: ds.lastCycleTimeISO || null
-        },
-        quality: {
-          best: Number(bestQ),
-          last: Number(lastQ),
-          baselineTypeErrors: ds.typeErrorBaseline || 0
-        },
-        cost: {
-          totalUSD: totalCost,
-          tokensIn: tokIn,
-          tokensOut: tokOut
-        },
-        files: {
-          committed: fileState.committed.length,
-          quarantined
-        },
-        wisdomCount,
-        telemetry: {
-          file: telemetryFile,
-          count: telemetryCount,
-          last: lastTelemetry || null
-        },
-        recentLedger: ledger.slice(-5)
-      })
-    );
-    return;
-  }
-  const G = "\x1B[32m";
-  const Y = "\x1B[33m";
-  const R = "\x1B[0m";
-  const B = "\x1B[1m";
-  const runStatus = isRunning ? `${G}\u25CF RUNNING${R} (PID ${lockPid}, heartbeat ${Math.round((Date.now() - lastHeartbeat) / 1e3)}s ago)` : `${Y}\u25CB IDLE${R}`;
-  console.log(`
-${B}HoloDaemon Status${R}  ${runStatus}`);
-  console.log(`  State dir:  ${stateDir}
-`);
-  console.log(`${B}Session${R}`);
-  console.log(`  Total cycles:  ${totalCycles}`);
-  console.log(`  Last focus:    ${lastFocus}`);
-  console.log(`  Last cycle:    ${lastCycleTime}`);
-  console.log(`
-${B}Quality${R}`);
-  console.log(`  Best:      ${bestQ}`);
-  console.log(`  Last:      ${lastQ}`);
-  console.log(`  Baseline:  ${baseline}`);
-  const totalCostDisplay = totalCost.toFixed(4);
-  const tokInDisplay = tokIn.toLocaleString();
-  const tokOutDisplay = tokOut.toLocaleString();
-  console.log(`
-${B}Cost${R}`);
-  console.log(`  Total:      $${totalCostDisplay}`);
-  console.log(`  Tokens in:  ${tokInDisplay}`);
-  console.log(`  Tokens out: ${tokOutDisplay}`);
-  console.log(`
-${B}Files${R}`);
-  console.log(`  Committed:   ${fileState.committed.length}`);
-  console.log(`  Quarantined: ${quarantined}`);
-  console.log(`  Wisdom:      ${wisdomCount} entries`);
-  console.log(`  Telemetry:   ${telemetryCount} entries`);
-  const recent = ledger.slice(-5);
-  if (recent.length > 0) {
-    console.log(`
-${B}Recent Ledger Entries${R} (last ${recent.length})`);
-    for (const entry of recent) {
-      const ts = entry.timestamp ? new Date(entry.timestamp).toLocaleString() : "?";
-      const file = entry.candidate ? path.basename(entry.candidate) : "?";
-      const result = entry.result === "committed" ? `${G}committed${R}` : entry.result === "rolled_back" ? `${Y}rolled_back${R}` : entry.result || "?";
-      const sha = entry.commitSha ? ` (${entry.commitSha.slice(0, 7)})` : "";
-      console.log(`  ${ts}  ${file}  ${result}${sha}  focus:${entry.focus || "?"}`);
-    }
-  }
-  console.log("");
-}
-function showHelp() {
-  console.log(`
-HoloScript CLI \u2014 Headless Runner v5.0
-
-Usage:
-  holoscript run <file>     [--target node|python|ros2] [--profile headless|minimal|full] [--ticks <n>] [--daemon] [--debug]
-  holoscript test <file>    [--debug]
-  holoscript compile <file> [--target node|python] [--output <path>] [--enforce-gotchas]
-  holoscript deploy <file>  [--share] [--publish] [--price <eth>] [--mint-nft] [--wallet-key <key>] [--author <name>] [--license <type>] [--server <url>]
-  holoscript absorb <file>  [--output <path>] [--debug]
-  holoscript daemon <file>  [--provider anthropic|xai|openai|ollama] [--tool-profile claude-hsplus|grok-hsplus|standard] [--cycles <n>] [--commit] [--model <model>] [--trial <n>] [--provider-rotation] [--always-on] [--cycle-interval-sec <n>] [--skills-dir <path>] [--allow-shell] [--allow-shell-command <cmd>] [--allow-host <host>] [--allow-path <path>] [--debug]
-  holoscript daemon status  [--json]
-
-Environment defaults (daemon):
-  HOLODAEMON_PROVIDER       anthropic|xai|openai|ollama
-  HOLODAEMON_TOOL_PROFILE   claude-hsplus|grok-hsplus|standard
-  HOLODAEMON_MODEL          model identifier for selected provider
-
-Supported file types:
-  .hs       Agent templates, behavior trees, event handlers
-  .hsplus   Full language with modules, types, async/await
-  .holo     Spatial compositions (optional render target)
-
-Examples:
-  holoscript run agent.hs --target node --debug
-  holoscript run agent.hs --daemon
-  holoscript test tests.hs
-  holoscript compile service.hsplus --target python --output service.py
-  holoscript compile world.holo --enforce-gotchas
-  holoscript absorb legacy.py --output agent.hsplus
-  holoscript daemon compositions/self-improve-daemon.hsplus --cycles 15 --commit
-  holoscript daemon compositions/self-improve-daemon.hsplus --provider xai --model grok-3
-  holoscript daemon compositions/self-improve-daemon.hsplus --provider anthropic --tool-profile claude-hsplus
-  holoscript daemon compositions/self-improve-daemon.hsplus --provider-rotation --cycles 10
-  holoscript daemon status
-`);
-}
-async function main() {
-  const opts = parseArgs(process.argv);
-  switch (opts.command) {
-    case "run":
-      await runScript(opts);
-      break;
-    case "test":
-      await testScript(opts);
-      break;
-    case "compile":
-      compileScript(opts);
-      break;
-    case "deploy":
-      await deployScript(opts);
-      break;
-    case "absorb":
-      absorbScript(opts);
-      break;
-    case "daemon":
-    case "holodaemon":
-      await daemonScript(opts);
-      break;
-    case "holomesh-daemon":
-      await holoMeshDaemonScript(opts);
-      break;
-    case "daemon-status":
-      await daemonStatus(opts.json);
-      break;
-    case "help":
-    default:
-      showHelp();
-  }
-}
-main().catch((err) => {
-  console.error("[holoscript] Fatal error:", err.message);
-  process.exit(1);
-});
-
-export { daemonScript, holoMeshDaemonScript };
-//# sourceMappingURL=holoscript-runner.js.map
-//# sourceMappingURL=holoscript-runner.js.map