@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/apps/daemon/dist/memory/manager.js

@@ -0,0 +1,359 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { memoryRootDir } from "../paths.js";
+const defaultMemoryMode = "readonly";
+const maxSearchFiles = 400;
+const memoryProjectWriteChains = new Map();
+export async function memoryOverview(projectKey, mode = defaultMemoryMode) {
+    const root = projectMemoryRoot(projectKey);
+    await ensureMemoryFiles(projectKey);
+    const files = await listMemoryFiles(projectKey);
+    return {
+        projectKey,
+        mode,
+        root,
+        files,
+        updatedAt: new Date().toISOString(),
+    };
+}
+export async function readMemoryFile(projectKey, requestedPath) {
+    const resolved = resolveMemoryPath(projectKey, requestedPath);
+    const content = await fs.readFile(resolved.absPath, "utf8");
+    const lineCount = content.split(/\r?\n/).length;
+    const contentHash = hashContent(content);
+    return {
+        path: resolved.relPath,
+        layer: layerForPath(resolved.relPath),
+        content,
+        citations: [{ path: resolved.relPath, startLine: 1, endLine: Math.max(1, lineCount), contentHash }],
+    };
+}
+export async function writeMemory(input) {
+    return await withMemoryProjectWriteLock(input.projectKey, async () => writeMemoryUnlocked(input));
+}
+async function writeMemoryUnlocked(input) {
+    const text = input.text.trim();
+    if (!text)
+        throw new Error("memory text is required");
+    const target = memoryPathForLayer(input.projectKey, input.layer, input.date);
+    await ensureMemoryFiles(input.projectKey);
+    await fs.mkdir(path.dirname(target.absPath), { recursive: true });
+    const entry = formatMemoryEntry(input.layer, text, input.title);
+    await fs.appendFile(target.absPath, entry, "utf8");
+    return await summarizeFile(target.absPath, target.relPath, input.layer);
+}
+export async function searchMemory(projectKey, query, limit = 5, options = {}) {
+    await ensureMemoryFiles(projectKey);
+    const terms = query.toLowerCase().split(/[^\p{L}\p{N}_-]+/u).filter((term) => term.length >= 2);
+    const files = (await listMemoryFiles(projectKey))
+        .filter((file) => options.includeDaily !== false || file.layer !== "daily")
+        .slice(0, maxSearchFiles);
+    const results = [];
+    for (const file of files) {
+        const resolved = resolveMemoryPath(projectKey, file.path);
+        const content = await fs.readFile(resolved.absPath, "utf8").catch(() => "");
+        const contentHash = hashContent(content);
+        const chunks = chunkMarkdown(content, file.path, file.layer, contentHash);
+        for (const chunk of chunks) {
+            const score = scoreChunk(chunk.text, query, terms, file.layer);
+            if (score <= 0)
+                continue;
+            results.push({
+                id: stableMemoryId(projectKey, chunk.citation.path, String(chunk.citation.startLine), chunk.text),
+                layer: file.layer,
+                path: file.path,
+                ...(chunk.title ? { title: chunk.title } : {}),
+                snippet: compactSnippet(chunk.text),
+                citation: chunk.citation,
+                score,
+                updatedAt: file.updatedAt,
+            });
+        }
+    }
+    return results
+        .sort((left, right) => right.score - left.score || right.updatedAt.localeCompare(left.updatedAt))
+        .slice(0, Math.max(1, limit));
+}
+export async function prepareMemoryContext(options, promptText) {
+    if (options.mode === "off")
+        return { text: promptText, used: [], options };
+    const topN = Math.max(1, Math.min(8, options.topN ?? 3));
+    const used = await searchMemory(options.projectKey, promptText, topN, { includeDaily: false });
+    if (used.length === 0)
+        return { text: promptText, used, options };
+    const block = [
+        "Memory context for this turn:",
+        ...used.map((item, index) => `${index + 1}. [${item.path}:${item.citation.startLine}-${item.citation.endLine}] ${item.snippet}`),
+        "Use this context only when it is relevant. Do not reveal internal memory paths unless the user asks.",
+    ].join("\n");
+    return { text: `${block}\n\n${promptText}`, used, options };
+}
+export async function writeTurnMemory(options, input) {
+    if (!options || options.mode !== "readwrite")
+        return undefined;
+    const summary = [
+        `Request: ${input.requestId}`,
+        `Turn: ${input.turnId}`,
+        `Status: ${input.status}`,
+        "",
+        "Prompt:",
+        input.promptText.slice(0, 4000),
+        "",
+        "Output preview:",
+        input.outputPreview.slice(0, 4000) || "(no output preview)",
+    ].join("\n");
+    return await writeMemory({
+        projectKey: options.projectKey,
+        layer: "daily",
+        title: `Turn ${input.turnId}`,
+        text: summary,
+        date: new Date().toISOString().slice(0, 10),
+    });
+}
+export async function maybePromoteMemory(options, promptText) {
+    if (!options || options.mode !== "readwrite")
+        return undefined;
+    if (!/\bremember this\b|记住|记忆下来|save this memory/i.test(promptText))
+        return undefined;
+    const cleaned = promptText
+        .replace(/\bremember this\b[:：]?/ig, "")
+        .replace(/记住[:：]?/g, "")
+        .replace(/记忆下来[:：]?/g, "")
+        .replace(/save this memory[:：]?/ig, "")
+        .trim();
+    if (!cleaned)
+        return undefined;
+    return await writeMemory({
+        projectKey: options.projectKey,
+        layer: "curated",
+        title: "Promoted from read-write turn",
+        text: cleaned,
+    });
+}
+export async function promoteMemory(input) {
+    return await withMemoryProjectWriteLock(input.projectKey, async () => {
+        const resolved = resolveMemoryPath(input.projectKey, input.source.path);
+        const content = await fs.readFile(resolved.absPath, "utf8");
+        const currentHash = hashContent(content);
+        const citation = {
+            ...input.source,
+            contentHash: input.source.contentHash ?? currentHash,
+            stale: Boolean(input.source.contentHash && input.source.contentHash !== currentHash),
+        };
+        const lines = content.split(/\r?\n/);
+        const selected = lines.slice(Math.max(0, citation.startLine - 1), Math.max(citation.startLine, citation.endLine)).join("\n").trim();
+        if (!selected)
+            throw new Error("memory promotion source is empty");
+        const stalePrefix = citation.stale ? `Source changed since citation ${input.source.contentHash}. Current hash ${currentHash}.\n\n` : "";
+        return await writeMemoryUnlocked({
+            projectKey: input.projectKey,
+            layer: input.targetLayer,
+            title: input.title ?? `Promoted from ${citation.path}:${citation.startLine}-${citation.endLine}`,
+            text: `${stalePrefix}${selected}`,
+        });
+    });
+}
+export async function ensureMemoryFiles(projectKey) {
+    const root = projectMemoryRoot(projectKey);
+    await fs.mkdir(path.join(root, "memory"), { recursive: true });
+    await ensureFile(path.join(root, "USER.md"), "# User Memory\n\n");
+    await ensureFile(path.join(root, "MEMORY.md"), "# Project Memory\n\n");
+    const today = new Date().toISOString().slice(0, 10);
+    await ensureFile(path.join(root, "memory", `${today}.md`), `# Daily Memory ${today}\n\n`);
+}
+async function listMemoryFiles(projectKey) {
+    const root = projectMemoryRoot(projectKey);
+    const files = [];
+    for (const relPath of ["USER.md", "MEMORY.md"]) {
+        const absPath = path.join(root, relPath);
+        const summary = await summarizeFile(absPath, relPath, layerForPath(relPath)).catch(() => undefined);
+        if (summary)
+            files.push(summary);
+    }
+    const dailyDir = path.join(root, "memory");
+    const daily = await fs.readdir(dailyDir).catch(() => []);
+    for (const name of daily.filter((item) => /^\d{4}-\d{2}-\d{2}\.md$/.test(item)).sort().reverse()) {
+        const relPath = `memory/${name}`;
+        const summary = await summarizeFile(path.join(root, relPath), relPath, "daily").catch(() => undefined);
+        if (summary)
+            files.push(summary);
+    }
+    return files;
+}
+export async function memoryDocumentSnapshots(projectKey) {
+    await ensureMemoryFiles(projectKey);
+    const snapshots = [];
+    for (const file of await listMemoryFiles(projectKey)) {
+        const resolved = resolveMemoryPath(projectKey, file.path);
+        snapshots.push({ path: file.path, layer: file.layer, content: await fs.readFile(resolved.absPath, "utf8"), summary: file });
+    }
+    return snapshots;
+}
+export async function applyMemoryDocumentSnapshot(projectKey, snapshot) {
+    return await withMemoryProjectWriteLock(projectKey, async () => {
+        await ensureMemoryFiles(projectKey);
+        const resolved = resolveMemoryPath(projectKey, snapshot.path);
+        await fs.mkdir(path.dirname(resolved.absPath), { recursive: true });
+        const local = await fs.readFile(resolved.absPath, "utf8").catch(() => "");
+        const localContentHash = local ? hashContent(local) : undefined;
+        let next = snapshot.content;
+        let conflicted = false;
+        if (local && local !== snapshot.content) {
+            if (local.includes(snapshot.content))
+                next = local;
+            else if (snapshot.content.includes(local))
+                next = snapshot.content;
+            else {
+                conflicted = true;
+                next = `${local.trimEnd()}\n\n## Sync conflict ${new Date().toISOString()}\n\n${snapshot.content.trim()}\n`;
+            }
+        }
+        await fs.writeFile(resolved.absPath, next, { mode: 0o600 });
+        const summary = await summarizeFile(resolved.absPath, resolved.relPath, snapshot.layer);
+        return {
+            summary,
+            ...(conflicted ? {
+                conflict: {
+                    path: resolved.relPath,
+                    layer: snapshot.layer,
+                    ...(localContentHash ? { localContentHash } : {}),
+                    ...(snapshot.contentHash ? { remoteContentHash: snapshot.contentHash } : {}),
+                    mergedContentHash: summary.contentHash,
+                },
+            } : {}),
+        };
+    });
+}
+function projectMemoryRoot(projectKey) {
+    return path.join(memoryRootDir, safeSegment(projectKey));
+}
+function resolveMemoryPath(projectKey, requestedPath) {
+    const relPath = normalizeRelMemoryPath(requestedPath);
+    const root = projectMemoryRoot(projectKey);
+    const absPath = path.resolve(root, relPath);
+    if (!absPath.startsWith(path.resolve(root) + path.sep) && absPath !== path.resolve(root)) {
+        throw new Error("memory path escapes project root");
+    }
+    return { absPath, relPath };
+}
+function memoryPathForLayer(projectKey, layer, date) {
+    const root = projectMemoryRoot(projectKey);
+    if (layer === "user")
+        return { absPath: path.join(root, "USER.md"), relPath: "USER.md" };
+    if (layer === "curated")
+        return { absPath: path.join(root, "MEMORY.md"), relPath: "MEMORY.md" };
+    const day = sanitizeDate(date ?? new Date().toISOString().slice(0, 10));
+    return { absPath: path.join(root, "memory", `${day}.md`), relPath: `memory/${day}.md` };
+}
+function layerForPath(relPath) {
+    if (relPath === "USER.md")
+        return "user";
+    if (relPath === "MEMORY.md")
+        return "curated";
+    return "daily";
+}
+async function ensureFile(filePath, initial) {
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, initial, { mode: 0o600 });
+    }
+}
+async function withMemoryProjectWriteLock(projectKey, run) {
+    const previous = memoryProjectWriteChains.get(projectKey) ?? Promise.resolve();
+    const next = previous.then(run, run);
+    memoryProjectWriteChains.set(projectKey, next.catch(() => undefined));
+    try {
+        return await next;
+    }
+    finally {
+        if (memoryProjectWriteChains.get(projectKey) === next)
+            memoryProjectWriteChains.delete(projectKey);
+    }
+}
+async function summarizeFile(absPath, relPath, layer) {
+    const [stat, content] = await Promise.all([fs.stat(absPath), fs.readFile(absPath, "utf8")]);
+    return {
+        path: relPath,
+        layer,
+        updatedAt: new Date(stat.mtimeMs).toISOString(),
+        lineCount: content.length === 0 ? 0 : content.split(/\r?\n/).length,
+        byteSize: stat.size,
+        contentHash: hashContent(content),
+    };
+}
+function chunkMarkdown(content, relPath, layer, contentHash) {
+    const lines = content.split(/\r?\n/);
+    const chunks = [];
+    let start = 1;
+    let title;
+    let buffer = [];
+    const flush = (endLine) => {
+        const text = buffer.join("\n").trim();
+        if (text)
+            chunks.push({ ...(title ? { title } : {}), text, citation: { path: relPath, startLine: start, endLine: Math.max(start, endLine), contentHash } });
+        buffer = [];
+    };
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const heading = line.match(/^(#{1,3})\s+(.+)$/);
+        if (heading && buffer.length > 0) {
+            flush(index);
+            start = index + 1;
+            title = heading[2].trim();
+        }
+        else if (heading) {
+            start = index + 1;
+            title = heading[2].trim();
+        }
+        buffer.push(line);
+    }
+    flush(lines.length);
+    if (chunks.length === 0 && content.trim()) {
+        chunks.push({ text: content.trim(), citation: { path: relPath, startLine: 1, endLine: lines.length, contentHash }, ...(layer !== "daily" ? { title: relPath } : {}) });
+    }
+    return chunks;
+}
+function hashContent(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function scoreChunk(text, query, terms, layer) {
+    const haystack = text.toLowerCase();
+    const exact = query.trim() && haystack.includes(query.toLowerCase()) ? 20 : 0;
+    const termScore = terms.reduce((score, term) => score + (haystack.includes(term) ? 3 : 0), 0);
+    const layerBoost = layer === "user" ? 4 : layer === "curated" ? 3 : 1;
+    return exact + termScore + (termScore > 0 || exact > 0 ? layerBoost : 0);
+}
+function compactSnippet(text) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return compact.length <= 420 ? compact : `${compact.slice(0, 417)}...`;
+}
+function formatMemoryEntry(layer, text, title) {
+    const now = new Date().toISOString();
+    const heading = title?.trim() || (layer === "daily" ? `Working note ${now}` : `Memory ${now}`);
+    return `\n## ${heading}\n\n${text.trim()}\n`;
+}
+function stableMemoryId(...parts) {
+    return `mem_${createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 24)}`;
+}
+function safeSegment(value) {
+    const hash = createHash("sha256").update(value).digest("base64url").slice(0, 16);
+    const readable = value.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 48) || "default";
+    return `${readable}_${hash}`;
+}
+function normalizeRelMemoryPath(value) {
+    const normalized = value.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (normalized === "USER.md" || normalized === "MEMORY.md" || /^memory\/\d{4}-\d{2}-\d{2}\.md$/.test(normalized))
+        return normalized;
+    throw new Error("unsupported memory path");
+}
+function sanitizeDate(value) {
+    const match = value.match(/^(\d{4}-\d{2}-\d{2})/);
+    if (!match)
+        throw new Error("invalid memory date");
+    return match[1];
+}
+//# sourceMappingURL=manager.js.map

package/apps/daemon/dist/paths.d.ts

@@ -5,6 +5,9 @@ export declare const auditLogPath: string;
 export declare const relayOutboxPath: string;
 export declare const loopStorePath: string;
 export declare const loopStoreLockPath: string;
+export declare const gatewayStorePath: string;
+export declare const scheduleStorePath: string;
+export declare const memoryRootDir: string;
 export declare const pidPath: string;
 export declare const daemonScriptPath: string;
 export declare const daemonScriptRelativePath: string;

package/apps/daemon/dist/paths.js

@@ -10,6 +10,9 @@ export const auditLogPath = path.join(configDir, "audit.jsonl");
 export const relayOutboxPath = path.join(configDir, "outbox.jsonl");
 export const loopStorePath = path.join(configDir, "loops.json");
 export const loopStoreLockPath = path.join(configDir, "loops.json.lock");
+export const gatewayStorePath = path.join(configDir, "gateway.json");
+export const scheduleStorePath = path.join(configDir, "schedules.json");
+export const memoryRootDir = path.join(configDir, "memory");
 export const pidPath = path.join(configDir, "daemon.pid");
 export const daemonScriptPath = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./cli.ts" : "./cli.js", import.meta.url));
 export const daemonScriptRelativePath = path.relative(process.cwd(), daemonScriptPath);

package/apps/daemon/dist/relay/admission.d.ts

@@ -0,0 +1,30 @@
+import type { EncryptedEnvelope, PermissionMode } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+export type MachineAdmissionAck = {
+    type: "server:ack";
+    requestId: string;
+    ok: true;
+    sessionId?: string;
+    turnId?: string;
+    admission?: "accepted" | "replayed";
+    dispatch?: "queued" | "delivered";
+};
+export declare function admitMachineCreateSession(config: DaemonConfig, input: {
+    requestId: string;
+    sessionId?: string;
+    agent: string;
+    cwd: string;
+    name: string;
+    model?: string;
+    encryptedMetadata?: EncryptedEnvelope;
+}): Promise<MachineAdmissionAck>;
+export declare function admitMachinePrompt(config: DaemonConfig, input: {
+    requestId: string;
+    sessionId: string;
+    turnId: string;
+    encryptedPrompt: EncryptedEnvelope;
+    encryptedMemoryOptions?: EncryptedEnvelope;
+    permissionMode?: PermissionMode;
+    model?: string;
+    timeoutMs?: number;
+}): Promise<MachineAdmissionAck>;

package/apps/daemon/dist/relay/admission.js

@@ -0,0 +1,31 @@
+import { readRelayJson, relayHttpError } from "../relay-http.js";
+async function postMachineAdmission(config, path, body, fallback) {
+    const response = await fetch(`${config.relayUrl}${path}`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${config.machineToken}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok)
+        throw await relayHttpError(response, fallback);
+    const parsed = await readRelayJson(response, `${fallback}: relay response is not valid JSON`);
+    if (!isMachineAdmissionAck(parsed)) {
+        throw new Error(`${fallback}: relay did not return an admission ack`);
+    }
+    return parsed;
+}
+export async function admitMachineCreateSession(config, input) {
+    return await postMachineAdmission(config, "/api/machine/admissions/create-session", input, "Machine session admission failed");
+}
+export async function admitMachinePrompt(config, input) {
+    return await postMachineAdmission(config, "/api/machine/admissions/prompt", input, "Machine prompt admission failed");
+}
+function isMachineAdmissionAck(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return record.type === "server:ack" && record.ok === true && typeof record.requestId === "string";
+}
+//# sourceMappingURL=admission.js.map

package/apps/daemon/dist/relay/connection.js

@@ -1,10 +1,15 @@
 import { appendAudit } from "../audit.js";
+import { handleGatewayCommand } from "../gateway/handler.js";
 import { tickLoops } from "../loop/runner.js";
+import { handleMemoryCommand } from "../memory/handler.js";
+import { handleScheduleCommand } from "../schedule/handler.js";
+import { tickSchedules } from "../schedule/runner.js";
 import { handleListDirectory } from "../session/directory.js";
 import { handlePreviewFile } from "../session/file-preview.js";
 import { handleClose, handleCreateSession, handleImportHistoricalSession, handleListHistoricalSessions, handleResume } from "../session/lifecycle.js";
-import { handleCancel, handlePrompt } from "../session/prompt.js";
+import { handleCancel, handleOptionResponse, handlePrompt } from "../session/prompt.js";
 import { handleFork, handleRename, handleRewind } from "../session/primitives.js";
+import { handleReconcileTurn } from "../session/reconcile.js";
 import { parseRelayMessage, relayWsUrl } from "../relay-http.js";
 import { handleDevExec, handleDiagnose } from "./devtools.js";
 import { registerMachine } from "./register.js";
@@ -58,6 +63,18 @@ async function handleServerMessage(ws, config, message) {
         await handleDevExec(ws, config, message);
         return;
     }
+    if (message.type === "machine:gateway") {
+        await handleGatewayCommand(ws, config, message);
+        return;
+    }
+    if (message.type === "machine:schedule") {
+        await handleScheduleCommand(ws, config, message);
+        return;
+    }
+    if (message.type === "machine:memory") {
+        await handleMemoryCommand(ws, config, message);
+        return;
+    }
     if (message.type === "machine:importHistoricalSession") {
         await handleImportHistoricalSession(ws, config, message);
         return;
@@ -70,6 +87,14 @@ async function handleServerMessage(ws, config, message) {
         await handleCancel(ws, config, message);
         return;
     }
+    if (message.type === "machine:optionResponse") {
+        await handleOptionResponse(ws, config, message);
+        return;
+    }
+    if (message.type === "machine:reconcileTurn") {
+        await handleReconcileTurn(ws, config, message);
+        return;
+    }
     if (message.type === "machine:resume") {
         await handleResume(ws, config, message);
         return;
@@ -95,8 +120,10 @@ export async function connectOnce(config) {
     const ws = new WebSocket(relayWsUrl(config.relayUrl));
     console.log(`Connecting ${config.machineName} to ${relayWsUrl(config.relayUrl)}`);
     let loopTimer;
+    let scheduleTimer;
     await new Promise((resolve) => {
         ws.addEventListener("open", () => {
+            const onlineSinceMs = Date.now();
             setActiveRelaySocket(ws);
             send(ws, {
                 type: "hello",
@@ -109,6 +136,11 @@ export async function connectOnce(config) {
                     console.error(`Loop tick failed: ${error instanceof Error ? error.message : String(error)}`);
                 });
             }, 1000);
+            scheduleTimer = setInterval(() => {
+                void tickSchedules(config, onlineSinceMs).catch((error) => {
+                    console.error(`Schedule tick failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }, 1000);
         });
         ws.addEventListener("message", (event) => {
             let message;
@@ -133,6 +165,8 @@ export async function connectOnce(config) {
             clearActiveRelaySocket(ws);
             if (loopTimer)
                 clearInterval(loopTimer);
+            if (scheduleTimer)
+                clearInterval(scheduleTimer);
             console.log("Relay connection closed; reconnecting...");
             resolve();
         });
@@ -140,6 +174,8 @@ export async function connectOnce(config) {
             clearActiveRelaySocket(ws);
             if (loopTimer)
                 clearInterval(loopTimer);
+            if (scheduleTimer)
+                clearInterval(scheduleTimer);
             resolve();
         });
     });

package/apps/daemon/dist/relay/devtools.d.ts

@@ -1,4 +1,4 @@
-import type { MachineCommand } from "@happy-elves/shared";
+import type { MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 export declare function handleDiagnose(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleDevExec(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;

package/apps/daemon/dist/relay/register.js

@@ -22,6 +22,8 @@ function agentProfileForRegister(agent) {
         id: agent.id,
         label: agent.label,
         ...(agent.command ? { command: agent.command } : {}),
+        ...(agent.defaultModel ? { defaultModel: agent.defaultModel } : {}),
+        ...(agent.models && agent.models.length > 0 ? { models: agent.models } : {}),
         ...(agent.historyModel ? { historyModel: agent.historyModel } : {}),
         ...(agent.sessionPrimitives ? { sessionPrimitives: runtimeAgentPrimitives(agent.sessionPrimitives) } : {}),
     };

package/apps/daemon/dist/relay/send.d.ts

@@ -1,5 +1,5 @@
-import type { MachineClientMessage } from "@happy-elves/shared";
-import type { RuntimeTurn } from "@happy-elves/runtime";
+import type { MachineClientMessage } from "../../../../packages/shared/dist/index.js";
+import type { RuntimeTurn } from "../../../../packages/runtime/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 export declare function send(ws: WebSocket, message: unknown): void;
 export declare function configureRelaySender(config: DaemonConfig): void;

package/apps/daemon/dist/relay/send.js

@@ -8,12 +8,14 @@ const criticalMessageTypes = new Set([
     "machine:event",
     "machine:sessionTranscriptReplaced",
     "machine:sessionTranscriptPrepended",
+    "machine:sessionHeadAdvanced",
     "machine:turnDone",
     "machine:sessionResumed",
     "machine:sessionRewound",
     "machine:sessionForked",
     "machine:sessionRenamed",
     "machine:sessionClosed",
+    "machine:turnReconciled",
     "machine:error",
 ]);
 let activeRelaySocket = null;

package/apps/daemon/dist/relay-http.d.ts

@@ -1,4 +1,4 @@
-import { type PairingClaimResponse, type ServerMessage } from "@happy-elves/shared";
+import { type PairingClaimResponse, type ServerMessage } from "../../../packages/shared/dist/index.js";
 import { DaemonCliError } from "./errors.js";
 export declare function relayHttpError(response: Response, fallback: string): Promise<DaemonCliError>;
 export declare function readRelayJson(response: Response, fallback: string): Promise<unknown>;

package/apps/daemon/dist/runtime/external-provider.d.ts

@@ -1,4 +1,4 @@
-import type { HappyElvesRuntime } from "@happy-elves/runtime";
+import type { HappyElvesRuntime } from "../../../../packages/runtime/dist/index.js";
 export type ExternalProviderConfig = {
     id: string;
     command: string;