@addai/node 0.30.6 → 0.30.9

package/dist/capabilities.js

@@ -92,16 +92,45 @@ function runCmd(cmd, args, timeoutMs = 5000) {
         }
     });
 }
-// Curated model lists baked into the daemon. The CLIs don't expose a
-// stable "list models" command; the daemon reports whatever the
-// installed daemon version knows about, so bumping the daemon refreshes
-// the UI's dropdown.
+// Curated model lists baked into the daemon. The CLIs still expose no
+// non-interactive "list models" command, so this stays a constant — but
+// WHAT goes in it is what decides whether the UI's dropdown rots.
+//
+// Do not "fix" this by probing the CLI. Checked against Claude Code
+// 2.1.266: there is no `claude models` subcommand and no `claude config
+// list`. Both strings are read as a PROMPT — the CLI starts a billed
+// session and answers in prose. Probing that on every heartbeat would
+// spend money several times a minute and still return nothing parseable.
+//
+// `claude --help` documents the real contract instead: --model takes
+// "an alias for the latest model (e.g. 'fable', 'opus', or 'sonnet') or
+// a model's full name (e.g. 'claude-fable-5')".
+//
+// So the ALIASES lead the list. They are the only entries that cannot go
+// stale — the CLI resolves each to whatever is current in its tier — and
+// staleness is exactly what went wrong before: this list was still
+// offering claude-opus-4-1 and claude-sonnet-4-5 long after they were
+// superseded, and no amount of heartbeating fixes a wrong constant.
+// Pinned ids follow, newest first, for anyone who must hold one model.
+//
+// Availability is plan-gated (these nodes sign in with claude.ai
+// subscriptions, not API keys), so a listed model can still be refused
+// at spawn time — the CLI stays the source of truth for validity, the
+// same way model-filter.ts already assumes.
 const CLAUDE_MODELS = [
+    // Aliases — always the latest in their tier.
+    'opus',
+    'sonnet',
+    'haiku',
+    'fable',
+    // Pinned ids, newest first.
+    'claude-opus-5',
+    'claude-sonnet-5',
+    'claude-fable-5-1',
+    'claude-opus-4-8',
     'claude-opus-4-7',
     'claude-sonnet-4-6',
     'claude-haiku-4-5',
-    'claude-opus-4-1',
-    'claude-sonnet-4-5',
 ];
 const CODEX_MODELS = [
     'gpt-5',

package/dist/claude-print.js

@@ -11,6 +11,7 @@ exports.spawnClaudePrint = spawnClaudePrint;
 const child_process_1 = require("child_process");
 const claude_binary_1 = require("./claude-binary");
 const win_1 = require("./win");
+const claude_system_prompt_1 = require("./claude-system-prompt");
 /**
  * The text to emit for one flushed block, given what came before.
  *
@@ -174,9 +175,13 @@ function spawnClaudePrint(input) {
     // its node script instead (identity on POSIX). It can throw; so can
     // spawn() itself (synchronously, on win32). Surface either as a normal
     // rejected `done` so callers keep their single error path.
+    // An entity system prompt of tens of thousands of characters does not fit
+    // on a Windows command line — see claude-system-prompt.ts. No-op when it
+    // fits, which is every case that works today.
+    const sysPrompt = (0, claude_system_prompt_1.offloadLongSystemPrompt)(bin, args);
     let proc;
     try {
-        const inv = (0, win_1.resolveCliInvocation)(bin, args);
+        const inv = (0, win_1.resolveCliInvocation)(bin, sysPrompt.args);
         proc = (0, child_process_1.spawn)(inv.file, inv.args, {
             cwd: input.workingDirectory,
             env: { ...process.env, TERM: 'dumb' },
@@ -187,6 +192,7 @@ function spawnClaudePrint(input) {
         });
     }
     catch (err) {
+        sysPrompt.cleanup();
         const done = Promise.reject(err instanceof Error ? err : new Error(String(err)));
         // Mark handled now — the caller awaits `done` a few ticks later, and an
         // already-rejected promise with no handler would fire unhandledRejection.
@@ -332,6 +338,7 @@ function spawnClaudePrint(input) {
     const done = new Promise((resolve, reject) => {
         proc.once('error', reject);
         proc.once('exit', (code) => {
+            sysPrompt.cleanup();
             flushThinking();
             flushText();
             const trimmed = stderrBuf.trim();

package/dist/claude-spawn.js

@@ -47,6 +47,7 @@ const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
 const claude_binary_1 = require("./claude-binary");
 const win_1 = require("./win");
+const claude_system_prompt_1 = require("./claude-system-prompt");
 const mcp_config_1 = require("./mcp-config");
 const paths_1 = require("./paths");
 function resolveMcpFilter(workingDirectory, enabled) {
@@ -150,6 +151,11 @@ function spawnClaudeForRuntime(input) {
         ...entityFlags,
         ...claudeArgs,
     ];
+    // Same overflow as claude-print: a long --append-system-prompt does not fit
+    // on a Windows command line. Applied before the branch so both the ConPTY
+    // and the POSIX shell form get the shortened argv; cleaned up in onExit
+    // beside the temp MCP config.
+    const sysPrompt = (0, claude_system_prompt_1.offloadLongSystemPrompt)(claudeBin, effectiveArgs);
     let shell;
     let shellArgs;
     if (isWin) {
@@ -160,14 +166,14 @@ function spawnClaudeForRuntime(input) {
         // node script (run via process.execPath) or passes an .exe straight
         // through; either target parses argv via CommandLineToArgvW, matching
         // node-pty's quoting. ConPTY handles both fine.
-        const inv = (0, win_1.resolveCliInvocation)(claudeBin, effectiveArgs);
+        const inv = (0, win_1.resolveCliInvocation)(claudeBin, sysPrompt.args);
         shell = inv.file;
         shellArgs = inv.args;
     }
     else {
         // `exec "$@"` passes positional args straight through without shell escaping.
         shell = process.env.SHELL || '/bin/bash';
-        shellArgs = ['-l', '-c', 'exec "$@"', '_', claudeBin, ...effectiveArgs];
+        shellArgs = ['-l', '-c', 'exec "$@"', '_', claudeBin, ...sysPrompt.args];
     }
     const proc = pty.spawn(shell, shellArgs, {
         name: 'xterm-256color',
@@ -196,6 +202,7 @@ function spawnClaudeForRuntime(input) {
                 l(exitCode);
             }
             catch { }
+        sysPrompt.cleanup();
         // best-effort cleanup of any temp MCP config
         if (mcpConfigPath) {
             try {

package/dist/claude-system-prompt.d.ts

@@ -0,0 +1,18 @@
+/** Rough rendered length of `file` + `args` as one command line. Counts two
+ *  quotes and a separating space per argument — the shape a renderer uses for
+ *  anything that might contain whitespace. */
+export declare function commandLineLength(file: string, args: string[]): number;
+export interface OffloadResult {
+    args: string[];
+    /** Removes the temp file, if one was written. Safe to call more than once. */
+    cleanup: () => void;
+}
+/**
+ * Swap an oversized inline system prompt for a file-backed one.
+ *
+ * Returns the args unchanged (and a no-op cleanup) whenever the command line
+ * already fits, whenever there is no --append-system-prompt to move, or when
+ * the temp file cannot be written — in that last case the spawn is left to
+ * fail with its own error rather than a worse one invented here.
+ */
+export declare function offloadLongSystemPrompt(file: string, args: string[], isWindows?: boolean): OffloadResult;

package/dist/claude-system-prompt.js

@@ -0,0 +1,110 @@
+"use strict";
+// A long --append-system-prompt does not fit on a Windows command line.
+//
+// CreateProcess caps the entire command line at 32,767 characters, and an
+// entity's system prompt is routinely tens of thousands — Hannah's was 31,004,
+// which with the user prompt and the rest of the flags overflowed, and every
+// run died with a bare `spawn ENAMETOOLONG` and no hint of which argument was
+// to blame. POSIX is nowhere near its limit at these sizes (ARG_MAX is ~256KB
+// on macOS, ~2MB on Linux), which is why this only ever bit on Windows — and
+// only once claude could be spawned there at all.
+//
+// claude takes the same text from a file, so when the rendered command line
+// would not fit, the prompt is written to a temp file and the flag becomes
+// --append-system-prompt-file. ONLY when it would not fit: the inline form is
+// what every working install uses today and an older claude may not know the
+// -file variant, so nothing that currently works changes shape.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandLineLength = commandLineLength;
+exports.offloadLongSystemPrompt = offloadLongSystemPrompt;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const INLINE_FLAG = '--append-system-prompt';
+const FILE_FLAG = '--append-system-prompt-file';
+/** Head-room under the real 32,767 limit. Both node and node-pty escape quotes
+ *  and backslashes when they render argv into a command line, so what actually
+ *  reaches CreateProcess is longer than the sum of the arguments. */
+const WINDOWS_BUDGET = 30_000;
+/** POSIX only needs catching if a prompt has gone genuinely pathological. */
+const POSIX_BUDGET = 120_000;
+/** Rough rendered length of `file` + `args` as one command line. Counts two
+ *  quotes and a separating space per argument — the shape a renderer uses for
+ *  anything that might contain whitespace. */
+function commandLineLength(file, args) {
+    return args.reduce((n, a) => n + a.length + 3, file.length + 3);
+}
+/**
+ * Swap an oversized inline system prompt for a file-backed one.
+ *
+ * Returns the args unchanged (and a no-op cleanup) whenever the command line
+ * already fits, whenever there is no --append-system-prompt to move, or when
+ * the temp file cannot be written — in that last case the spawn is left to
+ * fail with its own error rather than a worse one invented here.
+ */
+function offloadLongSystemPrompt(file, args, isWindows = process.platform === 'win32') {
+    const noop = { args, cleanup: () => { } };
+    const budget = isWindows ? WINDOWS_BUDGET : POSIX_BUDGET;
+    if (commandLineLength(file, args) <= budget)
+        return noop;
+    const i = args.indexOf(INLINE_FLAG);
+    if (i < 0 || i + 1 >= args.length)
+        return noop;
+    const promptPath = path.join(os.tmpdir(), `ainode-sysprompt-${(0, crypto_1.randomUUID)()}.txt`);
+    try {
+        fs.writeFileSync(promptPath, args[i + 1], 'utf8');
+    }
+    catch {
+        return noop;
+    }
+    const next = args.slice();
+    next[i] = FILE_FLAG;
+    next[i + 1] = promptPath;
+    let removed = false;
+    return {
+        args: next,
+        cleanup: () => {
+            if (removed)
+                return;
+            removed = true;
+            try {
+                fs.unlinkSync(promptPath);
+            }
+            catch { /* swept from tmp anyway */ }
+        },
+    };
+}

package/dist/desktop/relay-client.js

@@ -71,13 +71,25 @@ const IDLE_CHECK_MS = 60_000;
  *  leaves a half-open socket that never fires 'close', so without this the
  *  client sits holding a dead handle and never reconnects. */
 const PING_INTERVAL_MS = 30_000;
+/** How often to ask the relay which deploy is answering. Cloud Run keeps a
+ *  retiring instance alive until its in-flight connections end — for this
+ *  socket, the hourly cut — so after a relay deploy this node sat attached to
+ *  the OLD instance, pongs and all, while every viewer landed on the new one
+ *  and was told the machine was offline. The relay's greeting names the
+ *  instance this socket reached; /health is answered by the live one. When
+ *  the two differ, move. */
+const REVISION_CHECK_MS = 60_000;
+const RELAY_HTTP_URL = RELAY_URL.replace(/^ws/, 'http');
 let ws = null;
 let stopped = true;
 let backoff = RECONNECT_MIN_MS;
 let idleTimer = null;
-let liveTimer = null;
-/** Set on every pong; cleared when a ping goes out. Two misses = dead. */
-let missedPongs = 0;
+/** Silences the CURRENT socket's timers; set when a socket opens so
+ *  stopRelayClient can reach them. Each socket owns its own timers and miss
+ *  count: a socket closing late used to clear the module-wide timer, which by
+ *  then belonged to its replacement — leaving the live socket with no ping
+ *  loop and no way to notice a dead link. */
+let clearCurrentTimers = null;
 /** viewerId -> that viewer's OWN TCP socket to the desktop's RFB port.
  *  Keyed per viewer, not per desktop: RFB is a stateful 1:1 protocol, so two
  *  people watching the same screen each need their own connection and their
@@ -157,16 +169,51 @@ async function connect() {
     }
     const sock = new ws_1.default(`${RELAY_URL}/node?token=${encodeURIComponent(token)}`);
     ws = sock;
+    // Which deploy of the relay this socket reached, from its greeting. Null
+    // until the relay says — an older relay never does, and then there is
+    // nothing to compare and the check stays quiet.
+    let attachedRevision = null;
+    /** Set on every pong; cleared when a ping goes out. Two misses = dead. */
+    let missedPongs = 0;
+    let pingTimer = null;
+    let revisionTimer = null;
+    const clearTimers = () => {
+        if (pingTimer) {
+            clearInterval(pingTimer);
+            pingTimer = null;
+        }
+        if (revisionTimer) {
+            clearInterval(revisionTimer);
+            revisionTimer = null;
+        }
+        if (clearCurrentTimers === clearTimers)
+            clearCurrentTimers = null;
+    };
+    const checkRevision = async () => {
+        if (!attachedRevision || sock.readyState !== ws_1.default.OPEN)
+            return;
+        let live;
+        try {
+            const res = await fetch(`${RELAY_HTTP_URL}/health`, { signal: AbortSignal.timeout(8_000) });
+            live = (await res.json()).revision;
+        }
+        catch {
+            return;
+        } // could not ask; the ping loop still guards the link
+        if (live && live !== attachedRevision && sock.readyState === ws_1.default.OPEN) {
+            console.warn(`[relay] the relay moved from ${attachedRevision} to ${live} — reconnecting`);
+            sock.terminate(); // 'close' → retry → redial, onto the live instance
+        }
+    };
     sock.on('open', () => {
         backoff = RECONNECT_MIN_MS;
-        missedPongs = 0;
-        if (liveTimer)
-            clearInterval(liveTimer);
+        clearCurrentTimers?.();
+        clearCurrentTimers = clearTimers;
         // A suspended Mac comes back with a socket that looks open and is not.
         // Ping until two go unanswered, then tear it down so the normal backoff
         // path reconnects - the daemon's own sleep detector reports the same
         // suspends this is guarding against.
-        liveTimer = setInterval(() => {
+        pingTimer = setInterval(() => {
             if (sock.readyState !== ws_1.default.OPEN) {
                 sock.terminate();
                 return;
@@ -184,6 +231,7 @@ async function connect() {
                 sock.terminate();
             }
         }, PING_INTERVAL_MS);
+        revisionTimer = setInterval(() => { void checkRevision(); }, REVISION_CHECK_MS);
     });
     sock.on('pong', () => { missedPongs = 0; });
     sock.on('message', async (raw) => {
@@ -208,6 +256,11 @@ async function connect() {
                 sock.send(JSON.stringify({ type: 'gone', viewerId, reason }));
             }
         };
+        if (msg.type === 'hello') {
+            attachedRevision = msg.revision ?? null;
+            console.log(`[relay] connected — relay revision ${attachedRevision ?? '?'}`);
+            return;
+        }
         if (msg.type === 'attach') {
             // Claim the viewer BEFORE the await, so a packet arriving during the
             // lookup is held rather than treated as arriving after a lost bridge.
@@ -312,10 +365,7 @@ async function connect() {
         }
     });
     const retry = () => {
-        if (liveTimer) {
-            clearInterval(liveTimer);
-            liveTimer = null;
-        }
+        clearTimers(); // only ever this socket's own
         if (ws !== sock)
             return; // superseded by a newer socket
         dropBridges();
@@ -338,10 +388,7 @@ function stopRelayClient() {
         clearTimeout(idleTimer);
         idleTimer = null;
     }
-    if (liveTimer) {
-        clearInterval(liveTimer);
-        liveTimer = null;
-    }
+    clearCurrentTimers?.();
     dropBridges();
     try {
         ws?.close();

package/dist/win.d.ts

@@ -34,6 +34,11 @@ export declare function resolveCliInvocation(bin: string, args: string[]): CliIn
  *  pnpm/yarn-classic write `"%~dp0\<rel>.js"` (batch parameter expansion —
  *  note: no trailing `%`). */
 declare function resolveNpmShimScript(shimPath: string): string | null;
+/** Parse a .cmd shim for a `%~dp0`-relative NATIVE executable, for packages
+ *  that ship one instead of a node script. Same two dialects and the same
+ *  on-disk check as resolveNpmShimScript; deliberately a separate function so
+ *  the npm path the auto-updater depends on is untouched by this. */
+declare function resolveShimExecutable(shimPath: string): string | null;
 /**
  * Kill an agent child process AND everything it spawned.
  *
@@ -99,5 +104,6 @@ export declare function linkDir(real: string, dest: string): void;
  *  worth exercising on any platform, not just on a Windows box. */
 export declare const __testables: {
     resolveNpmShimScript: typeof resolveNpmShimScript;
+    resolveShimExecutable: typeof resolveShimExecutable;
 };
 export {};

package/dist/win.js

@@ -203,11 +203,24 @@ function resolveCliInvocation(bin, args) {
     }
     if (/\.(cmd|bat)$/i.test(target)) {
         const script = resolveNpmShimScript(target);
-        if (!script) {
-            throw new Error(`cannot spawn npm shim safely: ${target} — could not resolve the node script it wraps. ` +
-                `Install the CLI's native Windows build (an .exe) or reinstall via npm.`);
-        }
-        return { file: process.execPath, args: [script, ...args] };
+        if (script)
+            return { file: process.execPath, args: [script, ...args] };
+        // Not every npm shim wraps a node script. A package may ship a native
+        // Windows binary and have its shim exec THAT:
+        //
+        //     "%dp0%\\node_modules\\@anthropic-ai\\claude-code\\bin\\claude.exe" %*
+        //
+        // which is what @anthropic-ai/claude-code does now. There is no .js to
+        // find, so this threw — and the capabilities probe swallows the throw and
+        // reports the harness `available: false`. On a machine where `claude
+        // --version` worked in every shell, claude was simply missing from the
+        // picker. The old message's advice ('install the native Windows build')
+        // was already satisfied: the .exe sits inside the package the shim names.
+        const exe = resolveShimExecutable(target);
+        if (exe)
+            return { file: exe, args };
+        throw new Error(`cannot spawn npm shim safely: ${target} — it wraps neither a node script ` +
+            `nor an executable this can find. Reinstall the CLI via npm.`);
     }
     return { file: target, args };
 }
@@ -245,6 +258,28 @@ function resolveNpmShimScript(shimPath) {
     const re = /%(?:~dp0|dp0%)[\\/]([^"\s]+\.(?:m|c)?js)/gi;
     for (const m of body.matchAll(re))
         candidates.push(m[1]);
+    // ⚠️ The CLI entry point first — NOT the file's order.
+    //
+    // npm's own npm.cmd names two %~dp0 scripts, and the helper comes first:
+    //
+    //     SET "NPM_PREFIX_JS=%~dp0\node_modules\npm\bin\npm-prefix.js"
+    //     SET "NPM_CLI_JS=%~dp0\node_modules\npm\bin\npm-cli.js"
+    //     ...
+    //     "%NODE_EXE%" "%NPM_CLI_JS%" %*
+    //
+    // Only that last line runs, and it runs NPM_CLI_JS. Taking the first that
+    // exists therefore spawned npm-prefix.js — and the reason this hid for so
+    // long is that doing so does not FAIL: it exits 0 and prints the npm prefix
+    // path. npmLatestVersion saw a clean exit whose output was not a version,
+    // returned null, and the auto-updater logged "could not read the latest
+    // published version" on every tick. A Windows node then sat for ever on the
+    // version it was installed with — the machine this was found on was still
+    // running 0.30.3 while 0.30.6 was published.
+    //
+    // Every package bin shim names exactly one script and is unaffected: the
+    // sort is stable, so with nothing to promote nothing moves.
+    const isCliEntry = (rel) => /(^|[\\/])(npm|npx)-cli\.(m|c)?js$/i.test(rel);
+    candidates.sort((a, b) => Number(isCliEntry(b)) - Number(isCliEntry(a)));
     for (const rel of candidates) {
         // Shims always write backslashes. Split on either separator and re-join
         // with the platform's, so the same parsing is exercisable off Windows —
@@ -256,6 +291,26 @@ function resolveNpmShimScript(shimPath) {
     }
     return null;
 }
+/** Parse a .cmd shim for a `%~dp0`-relative NATIVE executable, for packages
+ *  that ship one instead of a node script. Same two dialects and the same
+ *  on-disk check as resolveNpmShimScript; deliberately a separate function so
+ *  the npm path the auto-updater depends on is untouched by this. */
+function resolveShimExecutable(shimPath) {
+    let body;
+    try {
+        body = fs.readFileSync(shimPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const re = /%(?:~dp0|dp0%)[\\/]([^"\s]+\.exe)/gi;
+    for (const m of body.matchAll(re)) {
+        const exe = path.join(path.dirname(shimPath), ...m[1].split(/[\\/]+/));
+        if (fs.existsSync(exe))
+            return exe;
+    }
+    return null;
+}
 /** How long a POSIX agent gets to honour SIGINT before we stop asking. */
 const KILL_ESCALATE_MS = 3000;
 /** One `ps` snapshot as (pid, ppid) pairs. Empty on any failure — callers
@@ -444,4 +499,4 @@ function linkDir(real, dest) {
 }
 /** Exposed for tests only: the shim parsing is pure file-shape logic and is
  *  worth exercising on any platform, not just on a Windows box. */
-exports.__testables = { resolveNpmShimScript };
+exports.__testables = { resolveNpmShimScript, resolveShimExecutable };

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "@addai/node",
-  "version": "0.30.6",
-  "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
-  "license": "MIT",
-  "keywords": [
-    "addai",
-    "entity-studio",
-    "claude",
-    "codex",
-    "kimi",
-    "gemini",
-    "agent",
-    "daemon",
-    "supabase",
-    "mcp"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
-  },
-  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
-  "bugs": {
-    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
-  },
-  "type": "commonjs",
-  "main": "dist/index.js",
-  "bin": {
-    "ainode": "dist/cli.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist",
-    "scripts",
-    "README.md",
-    "assets"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
-    "start": "node dist/cli.js",
-    "dev": "tsc -p tsconfig.json && node dist/cli.js",
-    "test": "npm run build && node --test test/*.test.mjs",
-    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
-    "postinstall": "node scripts/fix-pty-helper.js",
-    "prepublishOnly": "npm run build"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@addai/node-flows": "^1.0.0",
-    "node-pty": "^1.1.0",
-    "ws": "^8.21.3"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.6.0"
-  }
-}
+{
+  "name": "@addai/node",
+  "version": "0.30.9",
+  "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
+  "license": "MIT",
+  "keywords": [
+    "addai",
+    "entity-studio",
+    "claude",
+    "codex",
+    "kimi",
+    "gemini",
+    "agent",
+    "daemon",
+    "supabase",
+    "mcp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
+  },
+  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
+  "bugs": {
+    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "ainode": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "assets"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
+    "start": "node dist/cli.js",
+    "dev": "tsc -p tsconfig.json && node dist/cli.js",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+    "postinstall": "node scripts/fix-pty-helper.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@addai/node-flows": "^1.0.0",
+    "node-pty": "^1.1.0",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.6.0"
+  }
+}