@holoscript/core 7.0.0 → 8.0.1

package/dist/cli/holoscript-runner.cjs

@@ -0,0 +1,2255 @@
+#!/usr/bin/env node
+'use strict';
+
+var chunk2YSNA2F2_cjs = require('../chunk-2YSNA2F2.cjs');
+var chunkSLU6UPJI_cjs = require('../chunk-SLU6UPJI.cjs');
+var chunkXHIV6326_cjs = require('../chunk-XHIV6326.cjs');
+var chunkR75BSDH7_cjs = require('../chunk-R75BSDH7.cjs');
+var chunkT5J7ZKP3_cjs = require('../chunk-T5J7ZKP3.cjs');
+require('../chunk-NG77ATEW.cjs');
+require('../chunk-WRLUBRKS.cjs');
+require('../chunk-X3GJPRVK.cjs');
+require('../chunk-DTGBOSEM.cjs');
+require('../chunk-YKGPCZEE.cjs');
+require('../chunk-6EX3I5P4.cjs');
+var chunkE7JP3BS3_cjs = require('../chunk-E7JP3BS3.cjs');
+require('../chunk-HCCQLAA4.cjs');
+require('dotenv/config');
+var fs = require('fs');
+var path = require('path');
+var readline = require('readline');
+var child_process = require('child_process');
+var crypto = require('crypto');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
+
+chunkE7JP3BS3_cjs.init_safeJsonParse();
+var engineRuntimeModule;
+async function loadEngineRuntime() {
+  engineRuntimeModule ?? (engineRuntimeModule = await import('@holoscript/engine/runtime'));
+  return engineRuntimeModule;
+}
+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-6";
+  }
+}
+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: crypto.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;
+}
+async function createDaemonLLMProvider(opts) {
+  const {
+    AnthropicAdapter,
+    XAIAdapter,
+    OpenAIAdapter,
+    LocalLLMAdapter
+  } = await import('@holoscript/llm-provider');
+  if (opts.provider === "anthropic") {
+    const adapter2 = new AnthropicAdapter({
+      apiKey: process.env.ANTHROPIC_API_KEY || "",
+      defaultModel: opts.model
+    });
+    return {
+      chat: async ({ system, prompt, maxTokens }) => {
+        const result = await adapter2.complete({
+          messages: [
+            { role: "system", content: system },
+            { role: "user", content: prompt }
+          ],
+          maxTokens: maxTokens || 4096,
+          temperature: 0.2
+        });
+        return {
+          text: result.content,
+          inputTokens: result.usage?.promptTokens ?? 0,
+          outputTokens: result.usage?.completionTokens ?? 0
+        };
+      }
+    };
+  }
+  if (opts.provider === "xai") {
+    const adapter2 = new XAIAdapter({
+      apiKey: process.env.XAI_API_KEY || "",
+      defaultModel: opts.model
+    });
+    return {
+      chat: async ({ system, prompt, maxTokens }) => {
+        const result = await adapter2.complete({
+          messages: [
+            { role: "system", content: system },
+            { role: "user", content: prompt }
+          ],
+          maxTokens: maxTokens || 4096,
+          temperature: 0.2
+        });
+        return {
+          text: result.content,
+          inputTokens: result.usage?.promptTokens ?? 0,
+          outputTokens: result.usage?.completionTokens ?? 0
+        };
+      }
+    };
+  }
+  if (opts.provider === "openai") {
+    const adapter2 = new OpenAIAdapter({
+      apiKey: process.env.OPENAI_API_KEY || "",
+      defaultModel: opts.model,
+      ...process.env.OPENAI_BASE_URL && { baseURL: process.env.OPENAI_BASE_URL }
+    });
+    return {
+      chat: async ({ system, prompt, maxTokens }) => {
+        const result = await adapter2.complete({
+          messages: [
+            { role: "system", content: system },
+            { role: "user", content: prompt }
+          ],
+          maxTokens: maxTokens || 4096,
+          temperature: 0.2
+        });
+        return {
+          text: result.content,
+          inputTokens: result.usage?.promptTokens ?? 0,
+          outputTokens: result.usage?.completionTokens ?? 0
+        };
+      }
+    };
+  }
+  const ollamaUrl = process.env.OLLAMA_BASE_URL || process.env.OLLAMA_URL;
+  if (!ollamaUrl) {
+    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 adapter = new LocalLLMAdapter({
+    baseURL: ollamaUrl,
+    defaultModel: opts.model,
+    timeoutMs: 12e4
+  });
+  return {
+    chat: async ({ system, prompt }) => {
+      const result = await adapter.complete({
+        messages: [
+          { role: "system", content: system },
+          { role: "user", content: prompt }
+        ],
+        maxTokens: 4096,
+        temperature: 0.2
+      });
+      return {
+        text: result.content,
+        inputTokens: result.usage?.promptTokens ?? 0,
+        outputTokens: result.usage?.completionTokens ?? 0
+      };
+    }
+  };
+}
+function createNodeHostCapabilities(cwd) {
+  return {
+    fileSystem: {
+      readFile: (filePath) => fs__namespace.readFileSync(path__namespace.resolve(cwd, filePath), "utf-8"),
+      writeFile: (filePath, content) => {
+        fs__namespace.writeFileSync(path__namespace.resolve(cwd, filePath), content, "utf-8");
+      },
+      deleteFile: (filePath) => {
+        fs__namespace.rmSync(path__namespace.resolve(cwd, filePath), { force: true });
+      },
+      exists: (filePath) => fs__namespace.existsSync(path__namespace.resolve(cwd, filePath))
+    },
+    process: {
+      exec: (command, args = [], options) => new Promise((resolve2, reject) => {
+        const child = child_process.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();
+  }
+}
+function getDaemonState(runtime, key) {
+  if (typeof key === "string") {
+    if (typeof runtime.get === "function") {
+      return runtime.get(key);
+    }
+    const value = runtime.getState(key);
+    if (value && typeof value === "object" && key in value) {
+      return value[key];
+    }
+    return value;
+  }
+  if (typeof runtime.getAllState === "function") {
+    return runtime.getAllState();
+  }
+  return runtime.getState();
+}
+function setDaemonState(runtime, key, value) {
+  if (typeof runtime.set === "function") {
+    runtime.set(key, value);
+    return;
+  }
+  if (runtime.setState.length <= 1) {
+    runtime.setState({ [key]: value });
+    return;
+  }
+  runtime.setState(key, value);
+}
+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__namespace.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 = chunkE7JP3BS3_cjs.readJson(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 = getDaemonState(runtime, key);
+        send({ type: "daemon:ok", op, key, value });
+        break;
+      }
+      case "state:set": {
+        const key = command?.key;
+        if (typeof key === "string") {
+          setDaemonState(runtime, 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__namespace.resolve(opts.file);
+  if (!fs__namespace.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const source = fs__namespace.readFileSync(filePath, "utf-8");
+  const ext = path__namespace.extname(filePath);
+  console.log(`[holoscript] Running ${path__namespace.basename(filePath)} (target: ${opts.target})`);
+  const parseResult = chunkT5J7ZKP3_cjs.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 { createHeadlessRuntime, getProfile, HEADLESS_PROFILE } = await loadEngineRuntime();
+  const profile = opts.profile === "headless" ? HEADLESS_PROFILE : getProfile(opts.profile);
+  const runtime = createHeadlessRuntime(ast, {
+    profile,
+    tickRate: 10,
+    debug: opts.debug,
+    hostCapabilities: createNodeHostCapabilities(path__namespace.dirname(filePath))
+  });
+  chunk2YSNA2F2_cjs.registerStdlib(
+    runtime,
+    {
+      policy: {
+        rootDir: path__namespace.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__namespace.dirname(filePath))
+    }
+  );
+  new chunkSLU6UPJI_cjs.InteropContext(path__namespace.dirname(filePath));
+  if (opts.debug) {
+    console.log(`[holoscript] Profile: ${profile.name}`);
+    console.log(`[holoscript] Interop context: ${path__namespace.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 chunkXHIV6326_cjs.HotReloadWatcher({
+      watchPaths: [path__namespace.dirname(filePath)],
+      extensions: [".hs", ".hsplus", ".holo"],
+      debounceMs: 300,
+      mode: "soft"
+    });
+    watcher.on("reload", async (event) => {
+      console.log(`
+[holoscript] File changed: ${path__namespace.basename(event.filePath)}`);
+      console.log(`[holoscript] Re-running ${path__namespace.basename(filePath)}...`);
+      try {
+        const newSource = fs__namespace.readFileSync(filePath, "utf-8");
+        const newParseResult = chunkT5J7ZKP3_cjs.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__namespace.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__namespace.resolve(opts.file);
+  if (!fs__namespace.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const source = fs__namespace.readFileSync(filePath, "utf-8");
+  console.log(`[holoscript test] Running tests in ${path__namespace.basename(filePath)}`);
+  const parseResult = chunkT5J7ZKP3_cjs.parse(source);
+  const ast = parseResult.ast;
+  const { createHeadlessRuntime, HEADLESS_PROFILE } = await loadEngineRuntime();
+  const profile = HEADLESS_PROFILE;
+  const runtime = createHeadlessRuntime(ast, { profile, tickRate: 10, debug: opts.debug });
+  runtime.start();
+  const runtimeAccess = runtime;
+  for (let i = 0; i < 50; i++) runtimeAccess.tick();
+  const runner = new chunkXHIV6326_cjs.ScriptTestRunner({
+    debug: opts.debug,
+    runtimeState: runtimeAccess.getState()
+  });
+  const scriptResults = runner.runTestsFromSource(source, filePath);
+  const runtimeState = runtimeAccess.getState();
+  const compositionState = Object.keys(runtimeState).length > 0 ? runtimeState : chunk2YSNA2F2_cjs.CompositionTestRunner.extractStateFromSource(source);
+  const computedDefs = chunk2YSNA2F2_cjs.CompositionTestRunner.extractComputedFromSource(source);
+  const compositionRunner = new chunk2YSNA2F2_cjs.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__namespace.resolve(opts.file);
+  if (!fs__namespace.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const source = fs__namespace.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 = chunkT5J7ZKP3_cjs.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__namespace.basename(filePath)} \u2192 ${opts.target} \u2192 ${path__namespace.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__namespace.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__namespace.resolve(opts.file);
+  if (!fs__namespace.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const source = fs__namespace.readFileSync(filePath, "utf-8");
+  const fileName = path__namespace.basename(filePath);
+  const title = path__namespace.basename(filePath, path__namespace.extname(filePath));
+  console.log(`Parsing ${fileName}...`);
+  const ast = chunkT5J7ZKP3_cjs.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 = chunkR75BSDH7_cjs.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 = chunk2YSNA2F2_cjs.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 = chunk2YSNA2F2_cjs.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 = chunk2YSNA2F2_cjs.calculateRevenueDistribution(
+      priceWei,
+      provenance.author || "anonymous",
+      importChain
+    );
+    console.log("\nRevenue distribution:");
+    for (const line of chunk2YSNA2F2_cjs.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: chunk2YSNA2F2_cjs.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__namespace.resolve(opts.file);
+  if (!fs__namespace.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  const content = fs__namespace.readFileSync(filePath, "utf-8");
+  const ext = path__namespace.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__namespace.basename(filePath)} (${language}) \u2192 ${path__namespace.basename(outputPath)}`
+  );
+  const processor = new chunkXHIV6326_cjs.AbsorbProcessor();
+  const result = processor.absorb({ language, filePath, content });
+  fs__namespace.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__namespace.dirname(dir)) {
+    if (fs__namespace.existsSync(path__namespace.join(dir, ".git"))) return dir;
+    dir = path__namespace.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__namespace.existsSync(skillsDir)) return actions;
+  const files = fs__namespace.readdirSync(skillsDir).filter((name) => name.endsWith(".hsplus")).map((name) => path__namespace.join(skillsDir, name));
+  for (const file of files) {
+    const content = fs__namespace.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__namespace.resolve(opts.file);
+  if (!fs__namespace.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__namespace.dirname(filePath));
+  const source = fs__namespace.readFileSync(filePath, "utf-8");
+  const parseResult = chunkT5J7ZKP3_cjs.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__namespace.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__namespace.join(repoRoot, ".holoscript");
+  if (!fs__namespace.existsSync(stateDir)) fs__namespace.mkdirSync(stateDir, { recursive: true });
+  const lockFile = path__namespace.join(stateDir, "daemon.lock");
+  const lockData = { pid: process.pid, time: Date.now(), heartbeat: Date.now() };
+  if (fs__namespace.existsSync(lockFile)) {
+    try {
+      const existing = chunkE7JP3BS3_cjs.readJson(fs__namespace.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__namespace.writeFileSync(lockFile, JSON.stringify(lockData), "utf-8");
+  const heartbeatTimer = setInterval(() => {
+    try {
+      fs__namespace.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__namespace.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__namespace.readFileSync(path__namespace.resolve(repoRoot, p), "utf-8"),
+    writeFile: (p, c) => {
+      const resolved = path__namespace.resolve(repoRoot, p);
+      fs__namespace.mkdirSync(path__namespace.dirname(resolved), { recursive: true });
+      fs__namespace.writeFileSync(resolved, c, "utf-8");
+    },
+    exists: (p) => fs__namespace.existsSync(path__namespace.resolve(repoRoot, p)),
+    exec: (cmd, args = [], execOpts = {}) => new Promise((resolve2, reject) => {
+      const child = child_process.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__namespace.resolve(repoRoot, skillsDirRel);
+  if (!fs__namespace.existsSync(skillsDirAbs)) {
+    fs__namespace.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__namespace.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 = await 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__namespace.join(stateDir, "daemon-state.json");
+  const telemetryFile = path__namespace.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__namespace.existsSync(stateFile)) {
+    try {
+      daemonState = { ...daemonState, ...chunkE7JP3BS3_cjs.readJson(fs__namespace.readFileSync(stateFile, "utf-8")) };
+    } catch {
+    }
+  }
+  const fileStateFile = path__namespace.join(stateDir, "daemon-file-state.json");
+  if (fs__namespace.existsSync(fileStateFile)) {
+    try {
+      const fileState = chunkE7JP3BS3_cjs.readJson(fs__namespace.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);
+  }
+  const { createHeadlessRuntime, HEADLESS_PROFILE } = await loadEngineRuntime();
+  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__namespace.join(stateDir, "accumulated-wisdom.json");
+      let wisdomEntries = [];
+      try {
+        if (fs__namespace.existsSync(wisdomFile)) {
+          wisdomEntries = chunkE7JP3BS3_cjs.readJson(fs__namespace.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 = await 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 = chunkE7JP3BS3_cjs.jsonClone(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__namespace.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__namespace.writeFileSync(stateFile, JSON.stringify(daemonState, null, 2), "utf-8");
+    const fileState = getDaemonFileState(repoRoot);
+    fs__namespace.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__namespace.resolve(opts.file);
+  if (!fs__namespace.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+  if (!process.env.HOLOSCRIPT_API_KEY) {
+    console.error("[holomesh-daemon] HOLOSCRIPT_API_KEY environment variable is required");
+    process.exit(1);
+  }
+  const rawSource = fs__namespace.readFileSync(filePath, "utf-8");
+  const source = rawSource.replace(/^#(version|target|mode)\s+.*/gm, "");
+  const parseResult = chunkT5J7ZKP3_cjs.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__namespace.resolve(path__namespace.dirname(filePath), ".holoscript");
+  if (!fs__namespace.existsSync(stateDir)) fs__namespace.mkdirSync(stateDir, { recursive: true });
+  const stateFile = path__namespace.join(stateDir, "holomesh-state.json");
+  console.log(`[holomesh-daemon] Composition: ${path__namespace.basename(filePath)}`);
+  console.log(`[holomesh-daemon] Cycles: ${opts.cycles} | Always-on: ${opts.alwaysOn}`);
+  const lockFile = path__namespace.join(stateDir, "holomesh-daemon.lock");
+  const lockData = { pid: process.pid, time: Date.now(), heartbeat: Date.now() };
+  if (fs__namespace.existsSync(lockFile)) {
+    try {
+      const existing = chunkE7JP3BS3_cjs.readJson(fs__namespace.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__namespace.writeFileSync(lockFile, JSON.stringify(lockData), "utf-8");
+  const heartbeatTimer = setInterval(() => {
+    try {
+      fs__namespace.writeFileSync(lockFile, JSON.stringify({ ...lockData, heartbeat: Date.now() }), "utf-8");
+    } catch {
+    }
+  }, 3e4);
+  const cleanup = () => {
+    clearInterval(heartbeatTimer);
+    try {
+      fs__namespace.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.HOLOSCRIPT_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__namespace.join(path__namespace.dirname(stateFile), "holomesh-crdt.bin") : void 0,
+    peerStorePath: v2Enabled ? path__namespace.join(path__namespace.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)" : ""}`
+  );
+  const { createHeadlessRuntime, HEADLESS_PROFILE } = await loadEngineRuntime();
+  let cycle = 0;
+  while (opts.alwaysOn || cycle < opts.cycles) {
+    console.log(
+      `
+[holomesh-daemon] === Cycle ${cycle + 1}${opts.alwaysOn ? "" : `/${opts.cycles}`} ===`
+    );
+    const cycleAST = chunkE7JP3BS3_cjs.jsonClone(compositionAST);
+    materializeTraits(cycleAST);
+    const runtime = createHeadlessRuntime(cycleAST, {
+      profile: HEADLESS_PROFILE,
+      tickRate: 1,
+      debug: opts.debug,
+      hostCapabilities: createNodeHostCapabilities(path__namespace.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__namespace.join(repoRoot, ".holoscript");
+  if (!fs__namespace.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__namespace.join(stateDir, "daemon.lock");
+  let isRunning = false;
+  let lockPid = 0;
+  let lastHeartbeat = 0;
+  if (fs__namespace.existsSync(lockFile)) {
+    try {
+      const lock = chunkE7JP3BS3_cjs.readJson(fs__namespace.readFileSync(lockFile, "utf-8"));
+      lockPid = lock.pid;
+      lastHeartbeat = lock.heartbeat;
+      isRunning = Date.now() - lastHeartbeat < 12e4;
+    } catch {
+    }
+  }
+  const stateFile = path__namespace.join(stateDir, "daemon-state.json");
+  let ds = {};
+  if (fs__namespace.existsSync(stateFile)) {
+    try {
+      ds = chunkE7JP3BS3_cjs.readJson(fs__namespace.readFileSync(stateFile, "utf-8"));
+    } catch {
+    }
+  }
+  const fileStateFile = path__namespace.join(stateDir, "daemon-file-state.json");
+  let fileState = {
+    committed: [],
+    failures: {}
+  };
+  if (fs__namespace.existsSync(fileStateFile)) {
+    try {
+      fileState = chunkE7JP3BS3_cjs.readJson(fs__namespace.readFileSync(fileStateFile, "utf-8"));
+    } catch {
+    }
+  }
+  const wisdomFile = path__namespace.join(stateDir, "accumulated-wisdom.json");
+  let wisdomCount = 0;
+  if (fs__namespace.existsSync(wisdomFile)) {
+    try {
+      wisdomCount = chunkE7JP3BS3_cjs.readJson(fs__namespace.readFileSync(wisdomFile, "utf-8")).length;
+    } catch {
+    }
+  }
+  const ledgerFile = path__namespace.join(stateDir, "fix-ledger.json");
+  let ledger = [];
+  if (fs__namespace.existsSync(ledgerFile)) {
+    try {
+      ledger = chunkE7JP3BS3_cjs.readJson(fs__namespace.readFileSync(ledgerFile, "utf-8"));
+    } catch {
+    }
+  }
+  const telemetryFile = path__namespace.join(stateDir, "daemon-telemetry.jsonl");
+  let telemetryCount = 0;
+  let lastTelemetry;
+  if (fs__namespace.existsSync(telemetryFile)) {
+    try {
+      const lines = fs__namespace.readFileSync(telemetryFile, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      telemetryCount = lines.length;
+      if (lines.length > 0) {
+        lastTelemetry = chunkE7JP3BS3_cjs.readJson(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__namespace.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);
+});
+
+exports.daemonScript = daemonScript;
+exports.holoMeshDaemonScript = holoMeshDaemonScript;
+//# sourceMappingURL=holoscript-runner.cjs.map
+//# sourceMappingURL=holoscript-runner.cjs.map