@vibevibes/mcp 0.5.0 → 0.6.0

package/dist/server.js

@@ -15,8 +15,6 @@ import { ZodError } from "zod";
 import { EventEmitter } from "events";
 import { bundleForServer, bundleForClient, evalServerBundle, validateClientBundle } from "./bundler.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { TickEngine } from "./tick-engine.js";
-import { isProtocolExperience, loadProtocolManifest, createProtocolModule, SubprocessExecutor } from "./protocol.js";
 function formatZodError(err, toolName, tool) {
     const issues = err.issues.map((issue) => {
         const path = issue.path.length > 0 ? `'${issue.path.join(".")}'` : "input";
@@ -222,7 +220,6 @@ const HISTORY_MAX_LIMIT = 200;
 const DEFAULT_STREAM_RATE_LIMIT = 60;
 const STREAM_RATE_WINDOW_MS = 1000;
 const EVENT_BATCH_DEBOUNCE_MS = 50;
-const DEFAULT_TICK_RATE_MS = 50;
 const MAX_BATCH_CALLS = 10;
 const LONG_POLL_MAX_TIMEOUT_MS = 55000;
 const AGENT_CONTEXT_MAX_TIMEOUT_MS = 10000;
@@ -253,7 +250,6 @@ function defaultObserve(state, _event, _actorId) {
 let PORT = parseInt(process.env.PORT || String(DEFAULT_PORT), 10);
 let publicUrl = null;
 let room;
-let tickEngine = null;
 let _actorCounter = 0;
 const roomEvents = new EventEmitter();
 roomEvents.setMaxListeners(ROOM_EVENTS_MAX_LISTENERS);
@@ -345,9 +341,6 @@ function experienceNotLoadedError() {
 }
 // ── Experience discovery & loading ──────────────────────────
 function discoverEntryPath() {
-    const manifestPath = path.join(PROJECT_ROOT, "manifest.json");
-    if (fs.existsSync(manifestPath))
-        return manifestPath;
     const tsxPath = path.join(PROJECT_ROOT, "src", "index.tsx");
     if (fs.existsSync(tsxPath))
         return tsxPath;
@@ -355,15 +348,10 @@ function discoverEntryPath() {
     if (fs.existsSync(rootTsx))
         return rootTsx;
     throw new Error(`No experience found in ${PROJECT_ROOT}. ` +
-        `Create a manifest.json (protocol) or src/index.tsx (TypeScript).`);
+        `Create src/index.tsx (TypeScript).`);
 }
-const protocolExecutors = new Map();
 async function loadExperience() {
     const entryPath = discoverEntryPath();
-    if (isProtocolExperience(entryPath)) {
-        await loadProtocolExperience(entryPath);
-        return;
-    }
     const [sCode, cCode] = await Promise.all([
         bundleForServer(entryPath),
         bundleForClient(entryPath),
@@ -385,48 +373,6 @@ async function loadExperience() {
     };
     experienceError = null;
 }
-async function loadProtocolExperience(manifestPath) {
-    const manifestDir = path.dirname(manifestPath);
-    const manifest = loadProtocolManifest(manifestPath);
-    const existing = protocolExecutors.get(manifest.id);
-    if (existing)
-        existing.stop();
-    const executor = new SubprocessExecutor(manifest.toolProcess.command, manifest.toolProcess.args || [], manifestDir);
-    executor.start();
-    protocolExecutors.set(manifest.id, executor);
-    try {
-        await executor.send("init", { experienceId: manifest.id }, 5000);
-    }
-    catch { }
-    const mod = createProtocolModule(manifest, executor, manifestDir);
-    loadedExperience = {
-        module: mod,
-        clientBundle: "",
-        serverCode: JSON.stringify(manifest),
-        loadedAt: Date.now(),
-        sourcePath: manifestPath,
-    };
-    experienceError = null;
-    console.log(`[protocol] Loaded ${manifest.title} (${manifest.id}) — ${manifest.tools.length} tools`);
-}
-// ── Tick Engine lifecycle ──────────────────────────────────
-function maybeStartTickEngine() {
-    if (!loadedExperience)
-        return;
-    const manifest = loadedExperience.module?.manifest;
-    if (manifest?.netcode !== "tick")
-        return;
-    stopTickEngine();
-    const tickRateMs = manifest.tickRateMs || DEFAULT_TICK_RATE_MS;
-    tickEngine = new TickEngine(room, loadedExperience, roomEvents, tickRateMs);
-    tickEngine.start();
-}
-function stopTickEngine() {
-    if (tickEngine) {
-        tickEngine.stop();
-        tickEngine = null;
-    }
-}
 // ── Express app ────────────────────────────────────────────
 const app = express();
 app.use(express.json({ limit: JSON_BODY_LIMIT }));
@@ -1186,8 +1132,6 @@ app.get("/agent-context", (req, res) => {
         return room.events.filter(e => {
             if (requestingOwner && e.owner === requestingOwner)
                 return false;
-            if (e.actorId === "_tick-engine" || e.owner === "_system")
-                return false;
             return e.ts > since;
         }).sort((a, b) => a.ts - b.ts);
     };
@@ -1239,7 +1183,6 @@ app.get("/agent-context", (req, res) => {
             lastError,
             browserErrors: recentBrowserErrors.length > 0 ? recentBrowserErrors : undefined,
             participants: room.participantList(),
-            tickEngine: tickEngine ? { enabled: true, tickCount: tickEngine.getStatus().tickCount } : undefined,
             eventCursor,
         };
     };
@@ -1383,10 +1326,8 @@ app.post("/reset", (_req, res) => {
 // ── Sync (re-bundle) ──────────────────────────────────────
 app.post("/sync", async (_req, res) => {
     try {
-        stopTickEngine();
         await loadExperience();
         room.broadcastToAll({ type: "experience_updated" });
-        maybeStartTickEngine();
         const mod = getModule();
         res.json({ synced: true, title: mod?.manifest?.title });
     }
@@ -1411,14 +1352,6 @@ app.get("/experiences", async (_req, res) => {
             tags: mod.manifest.tags,
         }]);
 });
-// ── Tick status ────────────────────────────────────────────
-app.get("/tick-status", (_req, res) => {
-    if (!tickEngine) {
-        res.json({ enabled: false, tickRateMs: 0, tickCount: 0, behaviorsTotal: 0, behaviorsEnabled: 0, lastTick: null });
-        return;
-    }
-    res.json(tickEngine.getStatus());
-});
 // ── MCP config ─────────────────────────────────────────────
 app.get("/mcp-config", (_req, res) => {
     const serverUrl = getBaseUrl();
@@ -1436,21 +1369,6 @@ app.get("/mcp-config", (_req, res) => {
         ],
     });
 });
-// ── Protocol experience HTML canvas ───────────────────────
-app.get("/canvas", async (_req, res) => {
-    if (!loadedExperience) {
-        res.status(500).json({ error: experienceNotLoadedError() });
-        return;
-    }
-    const canvasPath = loadedExperience.module?._canvasPath;
-    if (!canvasPath) {
-        res.status(404).json({ error: "This experience has no HTML canvas" });
-        return;
-    }
-    res.setHeader("Content-Type", "text/html");
-    setNoCacheHeaders(res);
-    res.sendFile(canvasPath);
-});
 // ── Catch-all: serve viewer ─────────────────────────────────
 app.get("*", (req, res, next) => {
     if (req.path.startsWith("/tools/") || req.path.startsWith("/viewer/") ||
@@ -1497,7 +1415,6 @@ export async function startServer(config) {
     const mod = getModule();
     const initialState = resolveInitialState(mod);
     room = new Room(mod.manifest.id, initialState);
-    maybeStartTickEngine();
     console.log(`  Experience: ${mod.manifest.id}`);
     const server = http.createServer(app);
     const wss = new WebSocketServer({ server, maxPayload: WS_MAX_PAYLOAD_BYTES });
@@ -1835,11 +1752,9 @@ export async function startServer(config) {
         }
         debounceTimer = setTimeout(async () => {
             console.log(`\nFile changed${filename ? ` (${filename})` : ""}, rebuilding...`);
-            stopTickEngine();
             try {
                 await loadExperience();
                 room.broadcastToAll({ type: "experience_updated" });
-                maybeStartTickEngine();
                 smokeTestClientBundle(PORT);
                 console.log("Hot reload complete.");
             }
@@ -1847,7 +1762,6 @@ export async function startServer(config) {
                 experienceError = toErrorMessage(err);
                 console.error("Hot reload failed:", toErrorMessage(err));
                 room.broadcastToAll({ type: "build_error", error: toErrorMessage(err) });
-                maybeStartTickEngine();
             }
             finally {
                 if (rebuildingResolve) {

package/hooks/logic.js

@@ -92,8 +92,7 @@ export function formatPrompt(ctx) {
     }
     // ── 3. Events (what happened since last wake-up) ──────
     if (ctx.events && ctx.events.length > 0) {
-        const visibleEvents = ctx.events.filter((e) => e.actorId !== "_tick-engine" &&
-            e.owner !== "_system");
+        const visibleEvents = ctx.events;
         if (visibleEvents.length > 0) {
             for (const e of visibleEvents) {
                 const actor = e.role || e.owner || (e.actorId ? e.actorId.split("-")[0] : "?");
@@ -130,9 +129,7 @@ export function formatPrompt(ctx) {
 export function makeDecision(ctx, iteration) {
     if (ctx === null)
         return null;
-    const realEvents = ctx.events?.filter((e) => e.actorId !== "_tick-engine" &&
-        e.owner !== "_system") || [];
-    const hasEvents = realEvents.length > 0;
+    const hasEvents = (ctx.events?.length || 0) > 0;
     const hasError = !!ctx.lastError;
     const hasBrowserErrors = ctx.browserErrors != null && ctx.browserErrors.length > 0;
     const hasObserveError = !!ctx.observeError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibevibes/mcp",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "MCP server + runtime engine for vibevibes experiences",
   "type": "module",
   "main": "dist/index.js",

package/dist/protocol.d.ts

@@ -1,85 +0,0 @@
-/**
- * Protocol experience support.
- *
- * Loads experiences defined as manifest.json + subprocess tool handler.
- * The subprocess communicates via newline-delimited JSON over stdin/stdout.
- */
-import type { ExperienceModule } from "@vibevibes/sdk";
-export interface ProtocolManifest {
-    id: string;
-    version: string;
-    title: string;
-    description?: string;
-    initialState?: Record<string, any>;
-    tools: ProtocolToolDef[];
-    toolProcess: {
-        command: string;
-        args?: string[];
-    };
-    agents?: Array<{
-        role: string;
-        systemPrompt: string;
-        allowedTools?: string[];
-        autoSpawn?: boolean;
-        maxInstances?: number;
-    }>;
-    observe?: {
-        exclude?: string[];
-        include?: string[];
-    };
-    canvas?: string;
-    netcode?: "default" | "tick";
-    tickRateMs?: number;
-    streams?: Array<{
-        name: string;
-        input_schema: Record<string, any>;
-        rateLimit?: number;
-    }>;
-}
-interface ProtocolToolDef {
-    name: string;
-    description: string;
-    input_schema: Record<string, any>;
-    risk?: "low" | "medium" | "high";
-}
-interface RpcRequest {
-    id: string;
-    method: "tool" | "observe" | "stream" | "init" | "ping";
-    params: Record<string, any>;
-}
-interface RpcResponse {
-    id: string;
-    result?: Record<string, any>;
-    error?: {
-        message: string;
-        code?: string;
-    };
-}
-export declare class SubprocessExecutor {
-    private proc;
-    private pending;
-    private buffer;
-    private seq;
-    private command;
-    private args;
-    private cwd;
-    private restarting;
-    constructor(command: string, args: string[], cwd: string);
-    start(): void;
-    stop(): void;
-    private processBuffer;
-    send(method: RpcRequest["method"], params: Record<string, any>, timeoutMs?: number): Promise<RpcResponse>;
-    get running(): boolean;
-}
-export declare function isProtocolExperience(entryPath: string): boolean;
-export declare function loadProtocolManifest(manifestPath: string): ProtocolManifest;
-/**
- * Create a synthetic ExperienceModule from a protocol manifest.
- * Tool handlers proxy calls to the subprocess executor.
- */
-export declare function createProtocolModule(manifest: ProtocolManifest, executor: SubprocessExecutor, manifestDir: string): ExperienceModule & {
-    initialState?: Record<string, any>;
-    _executor: SubprocessExecutor;
-    _canvasPath?: string;
-};
-export {};

package/dist/protocol.js

@@ -1,240 +0,0 @@
-/**
- * Protocol experience support.
- *
- * Loads experiences defined as manifest.json + subprocess tool handler.
- * The subprocess communicates via newline-delimited JSON over stdin/stdout.
- */
-import { spawn } from "child_process";
-import * as path from "path";
-import * as fs from "fs";
-// ── Subprocess executor ─────────────────────────────────────────────────
-export class SubprocessExecutor {
-    proc = null;
-    pending = new Map();
-    buffer = "";
-    seq = 0;
-    command;
-    args;
-    cwd;
-    restarting = false;
-    constructor(command, args, cwd) {
-        this.command = command;
-        this.args = args;
-        this.cwd = cwd;
-    }
-    start() {
-        if (this.proc)
-            return;
-        this.proc = spawn(this.command, this.args, {
-            cwd: this.cwd,
-            stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env },
-        });
-        this.proc.stdout.on("data", (chunk) => {
-            this.buffer += chunk.toString();
-            this.processBuffer();
-        });
-        this.proc.stderr.on("data", (chunk) => {
-            const msg = chunk.toString().trim();
-            if (msg)
-                console.error(`[protocol:${this.command}] ${msg}`);
-        });
-        this.proc.on("exit", (code) => {
-            console.warn(`[protocol] Tool process exited with code ${code}`);
-            this.proc = null;
-            // Reject all pending requests
-            for (const [id, p] of this.pending) {
-                p.reject(new Error(`Tool process exited (code ${code})`));
-                clearTimeout(p.timer);
-            }
-            this.pending.clear();
-            this.buffer = "";
-            // Auto-restart after a short delay
-            if (!this.restarting) {
-                this.restarting = true;
-                setTimeout(() => {
-                    this.restarting = false;
-                    try {
-                        this.start();
-                    }
-                    catch { }
-                }, 1000);
-            }
-        });
-        this.proc.on("error", (err) => {
-            console.error(`[protocol] Failed to spawn tool process: ${err.message}`);
-        });
-    }
-    stop() {
-        this.restarting = true; // Prevent auto-restart
-        if (this.proc) {
-            this.proc.kill();
-            this.proc = null;
-        }
-        for (const [, p] of this.pending) {
-            p.reject(new Error("Executor stopped"));
-            clearTimeout(p.timer);
-        }
-        this.pending.clear();
-    }
-    processBuffer() {
-        const lines = this.buffer.split("\n");
-        this.buffer = lines.pop() || "";
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const response = JSON.parse(trimmed);
-                const pending = this.pending.get(response.id);
-                if (pending) {
-                    clearTimeout(pending.timer);
-                    this.pending.delete(response.id);
-                    pending.resolve(response);
-                }
-            }
-            catch {
-                console.warn(`[protocol] Invalid JSON from tool process: ${trimmed.slice(0, 200)}`);
-            }
-        }
-    }
-    async send(method, params, timeoutMs = 10000) {
-        if (!this.proc?.stdin?.writable) {
-            throw new Error("Tool process not running");
-        }
-        const id = `req-${++this.seq}`;
-        const request = { id, method, params };
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`Tool process timeout after ${timeoutMs}ms`));
-            }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
-            try {
-                this.proc.stdin.write(JSON.stringify(request) + "\n");
-            }
-            catch (err) {
-                clearTimeout(timer);
-                this.pending.delete(id);
-                reject(err instanceof Error ? err : new Error(String(err)));
-            }
-        });
-    }
-    get running() {
-        return this.proc !== null && !this.proc.killed;
-    }
-}
-// ── Load a protocol experience ──────────────────────────────────────────
-export function isProtocolExperience(entryPath) {
-    return entryPath.endsWith("manifest.json");
-}
-export function loadProtocolManifest(manifestPath) {
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-    if (!manifest.id)
-        throw new Error("manifest.json: id is required");
-    if (!manifest.version)
-        throw new Error("manifest.json: version is required");
-    if (!manifest.title)
-        throw new Error("manifest.json: title is required");
-    if (!manifest.toolProcess)
-        throw new Error("manifest.json: toolProcess is required");
-    if (!Array.isArray(manifest.tools))
-        throw new Error("manifest.json: tools must be an array");
-    return manifest;
-}
-/**
- * Create a synthetic ExperienceModule from a protocol manifest.
- * Tool handlers proxy calls to the subprocess executor.
- */
-export function createProtocolModule(manifest, executor, manifestDir) {
-    // Create tool defs with handlers that proxy to the subprocess
-    const tools = manifest.tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        // Use a plain object as input_schema with a parse method for compatibility
-        input_schema: createJsonSchemaValidator(t.input_schema),
-        risk: (t.risk || "low"),
-        capabilities_required: ["state.write"],
-        handler: async (ctx, input) => {
-            const response = await executor.send("tool", {
-                tool: t.name,
-                input,
-                state: ctx.state,
-                actorId: ctx.actorId,
-                roomId: ctx.roomId,
-                timestamp: ctx.timestamp,
-            });
-            if (response.error) {
-                throw new Error(response.error.message);
-            }
-            if (response.result?.state) {
-                ctx.setState(response.result.state);
-            }
-            return response.result?.output ?? {};
-        },
-    }));
-    // Build observe function if manifest specifies observation config
-    let observe;
-    if (manifest.observe) {
-        const { exclude, include } = manifest.observe;
-        observe = (state, _event, _actorId) => {
-            if (include) {
-                const filtered = {};
-                for (const key of include) {
-                    if (key in state)
-                        filtered[key] = state[key];
-                }
-                return filtered;
-            }
-            if (exclude) {
-                const filtered = { ...state };
-                for (const key of exclude) {
-                    delete filtered[key];
-                }
-                return filtered;
-            }
-            return state;
-        };
-    }
-    // Resolve canvas path
-    const canvasFile = manifest.canvas || "index.html";
-    const canvasPath = path.resolve(manifestDir, canvasFile);
-    const hasCanvas = fs.existsSync(canvasPath);
-    return {
-        manifest: {
-            id: manifest.id,
-            version: manifest.version,
-            title: manifest.title,
-            description: manifest.description || "",
-            requested_capabilities: ["state.write"],
-            agentSlots: manifest.agents,
-            participantSlots: manifest.agents?.map((a) => ({ ...a, type: "ai" })),
-            netcode: manifest.netcode,
-            tickRateMs: manifest.tickRateMs,
-        },
-        Canvas: (() => null), // Protocol experiences use HTML canvas, not React
-        tools,
-        observe,
-        initialState: manifest.initialState ?? {},
-        _executor: executor,
-        _canvasPath: hasCanvas ? canvasPath : undefined,
-    };
-}
-/**
- * Create a minimal Zod-compatible validator from a JSON Schema.
- * Only needs .parse() for the server's input validation.
- */
-function createJsonSchemaValidator(schema) {
-    return {
-        parse: (input) => {
-            // Basic type validation for protocol experiences
-            if (schema.type === "object" && typeof input !== "object") {
-                throw new Error("Expected object input");
-            }
-            return input;
-        },
-        // Expose the raw JSON Schema for tool listing
-        _jsonSchema: schema,
-    };
-}

package/dist/tick-engine.d.ts

@@ -1,81 +0,0 @@
-/**
- * Tick Engine — server-side tick loop for experiences with netcode: "tick".
- *
- * Runs at a fixed tick rate, executing tool calls from the tick context.
- * The tick engine provides the timing infrastructure; experiences define
- * what happens each tick via their tool handlers.
- */
-import type { ToolCtx, ToolEvent } from "@vibevibes/sdk";
-import type { EventEmitter } from "events";
-/** ToolEvent extended with observation field (computed server-side after tool execution). */
-interface TickToolEvent extends ToolEvent {
-    observation?: Record<string, unknown>;
-}
-/** Minimal Room interface — what the tick engine needs from a room. */
-export interface TickRoom {
-    readonly id: string;
-    readonly experienceId: string;
-    readonly config: Record<string, unknown>;
-    sharedState: Record<string, unknown>;
-    participantList(): string[];
-    broadcastToAll(message: Record<string, unknown>): void;
-    broadcastStateUpdate?(extra: {
-        changedBy: string;
-        tick?: unknown;
-    }, forceFullState?: boolean): void;
-    appendEvent(event: TickToolEvent): void;
-    enqueueExecution<T>(fn: () => Promise<T>): Promise<T>;
-}
-/** Minimal experience interface — what the tick engine needs. */
-export interface TickExperience {
-    module: {
-        manifest: {
-            id: string;
-        };
-        tools: Array<{
-            name: string;
-            input_schema?: {
-                parse?: (input: unknown) => unknown;
-            };
-            handler: (ctx: ToolCtx, input: unknown) => Promise<unknown>;
-        }>;
-        observe?: (state: Record<string, unknown>, event: TickToolEvent, actorId: string) => Record<string, unknown>;
-    };
-}
-export declare class TickEngine {
-    private room;
-    private experience;
-    private roomEvents;
-    private interval;
-    private tickCount;
-    private tickRateMs;
-    private startedAt;
-    private _running;
-    private _stopped;
-    private _stateSetThisTick;
-    constructor(room: TickRoom, experience: TickExperience, roomEvents: EventEmitter, tickRateMs?: number);
-    /** Start the tick loop. Uses self-correcting setTimeout to prevent timing drift. */
-    start(): void;
-    /** Schedule the next tick with drift correction. */
-    private scheduleNext;
-    /** Stop the tick loop. */
-    stop(): void;
-    /** Mark dirty — no-op in simplified engine, kept for API compat. */
-    markDirty(): void;
-    /** Get current tick status. */
-    getStatus(): {
-        enabled: boolean;
-        tickRateMs: number;
-        tickCount: number;
-    };
-    /** Execute one tick cycle. */
-    private tick;
-    /** Execute a tool call internally (no HTTP round-trip). */
-    executeTool(toolName: string, input: Record<string, unknown>, callerActorId?: string, expiredFlag?: {
-        value: boolean;
-    }): Promise<{
-        output?: unknown;
-        error?: string;
-    }>;
-}
-export {};

package/dist/tick-engine.js

@@ -1,151 +0,0 @@
-/**
- * Tick Engine — server-side tick loop for experiences with netcode: "tick".
- *
- * Runs at a fixed tick rate, executing tool calls from the tick context.
- * The tick engine provides the timing infrastructure; experiences define
- * what happens each tick via their tool handlers.
- */
-// ── Tick Engine ───────────────────────────────────────────────────────────────
-const TICK_ACTOR_ID = "_tick-engine";
-const TICK_OWNER = "_system";
-export class TickEngine {
-    room;
-    experience;
-    roomEvents;
-    interval = null;
-    tickCount = 0;
-    tickRateMs;
-    startedAt = 0;
-    _running = false;
-    _stopped = false;
-    _stateSetThisTick = false;
-    constructor(room, experience, roomEvents, tickRateMs = 50) {
-        this.room = room;
-        this.experience = experience;
-        this.roomEvents = roomEvents;
-        this.tickRateMs = tickRateMs;
-    }
-    /** Start the tick loop. Uses self-correcting setTimeout to prevent timing drift. */
-    start() {
-        if (this.interval)
-            return;
-        this._stopped = false;
-        this.tickCount = 0;
-        this.startedAt = Date.now();
-        this.scheduleNext();
-    }
-    /** Schedule the next tick with drift correction. */
-    scheduleNext() {
-        if (this._stopped)
-            return;
-        const expected = this.startedAt + (this.tickCount + 1) * this.tickRateMs;
-        const delay = Math.max(0, expected - Date.now());
-        this.interval = setTimeout(() => {
-            this.tick().then(() => this.scheduleNext(), () => this.scheduleNext());
-        }, delay);
-    }
-    /** Stop the tick loop. */
-    stop() {
-        this._stopped = true;
-        this._running = false;
-        if (this.interval) {
-            clearTimeout(this.interval);
-            this.interval = null;
-        }
-    }
-    /** Mark dirty — no-op in simplified engine, kept for API compat. */
-    markDirty() { }
-    /** Get current tick status. */
-    getStatus() {
-        return {
-            enabled: this.interval !== null,
-            tickRateMs: this.tickRateMs,
-            tickCount: this.tickCount,
-        };
-    }
-    /** Execute one tick cycle. */
-    async tick() {
-        if (this._running)
-            return;
-        this._running = true;
-        try {
-            this.tickCount++;
-        }
-        finally {
-            this._running = false;
-        }
-    }
-    /** Execute a tool call internally (no HTTP round-trip). */
-    async executeTool(toolName, input, callerActorId, expiredFlag) {
-        const tool = this.experience.module.tools.find((t) => t.name === toolName);
-        if (!tool) {
-            return { error: `Tool '${toolName}' not found` };
-        }
-        const actorId = callerActorId || TICK_ACTOR_ID;
-        const owner = callerActorId || TICK_OWNER;
-        try {
-            let validatedInput = input;
-            if (tool.input_schema?.parse) {
-                validatedInput = tool.input_schema.parse(input);
-            }
-            const self = this;
-            const ctxBase = {
-                roomId: this.room.id,
-                actorId,
-                owner,
-                state: null,
-                setState: (newState) => {
-                    if (expiredFlag?.value)
-                        return;
-                    self.room.sharedState = newState;
-                    self._stateSetThisTick = true;
-                },
-                timestamp: Date.now(),
-                memory: {},
-                setMemory: () => { },
-            };
-            Object.defineProperty(ctxBase, 'state', {
-                get() { return self.room.sharedState; },
-                enumerable: true,
-                configurable: true,
-            });
-            const ctx = ctxBase;
-            const output = await tool.handler(ctx, validatedInput);
-            const event = {
-                id: `tick-${this.tickCount}-${toolName}-${Math.random().toString(36).slice(2, 6)}`,
-                ts: Date.now(),
-                actorId: TICK_ACTOR_ID,
-                owner: TICK_OWNER,
-                tool: toolName,
-                input: validatedInput,
-                output,
-            };
-            if (this.experience.module.observe) {
-                try {
-                    event.observation = this.experience.module.observe(this.room.sharedState, event, actorId);
-                }
-                catch {
-                    // Don't fail tick if observe throws
-                }
-            }
-            this.room.appendEvent(event);
-            this.roomEvents.emit(`room:${this.room.id}`);
-            return { output };
-        }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            const event = {
-                id: `tick-${this.tickCount}-${toolName}-${Math.random().toString(36).slice(2, 6)}`,
-                ts: Date.now(),
-                actorId: TICK_ACTOR_ID,
-                owner: TICK_OWNER,
-                tool: toolName,
-                input,
-                error: errorMsg,
-            };
-            this.room.appendEvent(event);
-            this.roomEvents.emit(`room:${this.room.id}`);
-            return { error: errorMsg };
-        }
-    }
-}