@cydm/happy-elves 0.1.0-beta.86 → 0.1.0-beta.87

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.86",
+  "version": "0.1.0-beta.87",
   "private": true,
   "type": "module"
 }

package/apps/daemon/dist/session/prompt.d.ts

@@ -1,4 +1,30 @@
 import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig } from "../types.js";
+type PromptCommand = Extract<MachineCommand, {
+    type: "machine:prompt";
+}>;
+type PromptExecutionPhase = "decrypt-prompt" | "decrypt-memory-options" | "prepare-memory-context" | "emit-submitted" | "emit-memory-status" | "start-turn" | "attach-turn" | "audit-turn-start" | "stream-turn" | "await-turn-result" | "write-memory" | "refresh-runtime-metadata" | "emit-terminal" | "refresh-authoritative-transcript" | "send-turn-done" | "terminal-hooks";
 export declare function handlePrompt(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export declare function promptFailureResponse(command: PromptCommand, phase: PromptExecutionPhase, error: unknown): {
+    type: "machine:error";
+    requestId: string;
+    sessionId: string;
+    code: string;
+    message: string;
+};
+export declare function promptFailureAuditEvent(config: Pick<DaemonConfig, "machineId">, command: PromptCommand, phase: PromptExecutionPhase, error: unknown): {
+    sessionId: string;
+    machineId: string;
+    actor: "system";
+    action: string;
+    summary: string;
+    evidence: {
+        requestId: string;
+        turnId: string;
+        code: string;
+        phase: PromptExecutionPhase;
+        message: string;
+    };
+};
 export declare function handleCancel(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export {};

package/apps/daemon/dist/session/prompt.js

@@ -52,19 +52,24 @@ export async function handlePrompt(ws, config, command) {
         activePromptRequests.delete(command.requestId);
         releaseSessionTurn(command.sessionId, command.requestId);
     };
+    let phase = "decrypt-prompt";
     try {
         const prompt = await decryptJson(config.accountSecret, command.encryptedPrompt);
         const rawText = prompt.type === "user_prompt" ? prompt.text : JSON.stringify(prompt);
+        phase = "decrypt-memory-options";
         const memoryOptions = await decryptMemoryOptions(config, command);
+        phase = "prepare-memory-context";
         const memoryContext = memoryOptions
             ? await prepareMemoryContext(memoryOptions, rawText)
             : { text: rawText, used: [], options: undefined };
         const text = memoryContext.text;
+        phase = "emit-submitted";
         await emitEvent(ws, config, command.sessionId, command.turnId, {
             type: "status",
             text: "Prompt submitted to runtime",
         });
         if (memoryOptions) {
+            phase = "emit-memory-status";
             await emitEvent(ws, config, command.sessionId, command.turnId, {
                 type: "status",
                 tag: "memory",
@@ -90,6 +95,7 @@ export async function handlePrompt(ws, config, command) {
             }
         }
         const previousBackendSessionId = session.handle.backendSessionId;
+        phase = "start-turn";
         const turn = getRuntime(session.cwd).startTurn({
             handle: session.handle,
             text,
@@ -98,9 +104,11 @@ export async function handlePrompt(ws, config, command) {
             requestId: command.requestId,
             timeoutMs: command.timeoutMs,
         });
+        phase = "attach-turn";
         if (!attachClaimedTurn(command.sessionId, command.requestId, command.turnId, turn)) {
             throw new Error(`Session turn claim was lost before start: ${command.sessionId}`);
         }
+        phase = "audit-turn-start";
         await appendAudit({
             sessionId: command.sessionId,
             machineId: config.machineId,
@@ -118,6 +126,7 @@ export async function handlePrompt(ws, config, command) {
             },
         });
         let outputPreview = "";
+        phase = "stream-turn";
         for await (const event of turn.events) {
             const payload = runtimeEventToPayload(event);
             if (payload.type === "text_delta" && payload.stream !== "thought") {
@@ -125,7 +134,9 @@ export async function handlePrompt(ws, config, command) {
             }
             await emitEvent(ws, config, command.sessionId, command.turnId, payload);
         }
+        phase = "await-turn-result";
         const result = await turn.result;
+        phase = "write-memory";
         const dailyMemory = await writeTurnMemory(memoryOptions, {
             promptText: rawText,
             outputPreview,
@@ -144,6 +155,7 @@ export async function handlePrompt(ws, config, command) {
                 ].filter(Boolean).join(" · "),
             });
         }
+        phase = "refresh-runtime-metadata";
         const refreshedMetadata = session.handle.backendSessionId
             ? await encryptedSessionMetadata(config, command.sessionId, session, {
                 currentHead: result.currentHead,
@@ -165,6 +177,7 @@ export async function handlePrompt(ws, config, command) {
                 },
             });
         }
+        phase = "emit-terminal";
         await emitEvent(ws, config, command.sessionId, command.turnId, result.status === "failed"
             ? {
                 type: "done",
@@ -180,8 +193,10 @@ export async function handlePrompt(ws, config, command) {
                 currentHead: result.currentHead,
                 lastTurnId: result.lastTurnId,
             });
+        phase = "refresh-authoritative-transcript";
         await refreshAuthoritativeTranscriptAfterTurn(ws, config, session, command.requestId, result.currentHead, result.lastTurnId, result.status);
         releasePromptTurn();
+        phase = "send-turn-done";
         await sendReliable({
             type: "machine:turnDone",
             sessionId: command.sessionId,
@@ -192,6 +207,7 @@ export async function handlePrompt(ws, config, command) {
             error: result.status === "failed" ? result.error.message : undefined,
             encryptedMetadata: refreshedMetadata,
         }, ws);
+        phase = "terminal-hooks";
         await handleGatewayTurnTerminal(config, {
             sessionId: command.sessionId,
             requestId: command.requestId,
@@ -231,10 +247,82 @@ export async function handlePrompt(ws, config, command) {
             },
         });
     }
+    catch (error) {
+        const response = promptFailureResponse(command, phase, error);
+        await appendAudit(promptFailureAuditEvent(config, command, phase, error)).catch((auditError) => {
+            console.error(`Prompt failure audit failed for ${command.turnId}: ${auditError instanceof Error ? auditError.message : String(auditError)}`);
+        });
+        await sendCommandResponse(ws, response);
+    }
     finally {
         releasePromptTurn();
     }
 }
+export function promptFailureResponse(command, phase, error) {
+    const code = promptFailureCode(phase, error);
+    return {
+        type: "machine:error",
+        requestId: command.requestId,
+        sessionId: command.sessionId,
+        code,
+        message: promptFailureMessage(code, error),
+    };
+}
+export function promptFailureAuditEvent(config, command, phase, error) {
+    const code = promptFailureCode(phase, error);
+    return {
+        sessionId: command.sessionId,
+        machineId: config.machineId,
+        actor: "system",
+        action: "turn.prompt.failed",
+        summary: `Failed to run prompt turn ${command.turnId}`,
+        evidence: {
+            requestId: command.requestId,
+            turnId: command.turnId,
+            code,
+            phase,
+            message: safeErrorMessage(error),
+        },
+    };
+}
+function promptFailureCode(phase, error) {
+    if (phase === "decrypt-prompt" && isCryptoOperationFailure(error))
+        return "PROMPT_DECRYPT_FAILED";
+    if (phase === "decrypt-memory-options" && isCryptoOperationFailure(error))
+        return "MEMORY_OPTIONS_DECRYPT_FAILED";
+    if (phase === "start-turn" || phase === "attach-turn")
+        return "TURN_START_FAILED";
+    if (phase === "stream-turn" || phase === "await-turn-result")
+        return "TURN_RUNTIME_FAILED";
+    if (phase === "refresh-runtime-metadata")
+        return "SESSION_METADATA_REFRESH_FAILED";
+    if (phase === "emit-submitted" || phase === "emit-memory-status" || phase === "emit-terminal")
+        return "SESSION_EVENT_EMIT_FAILED";
+    return "PROMPT_EXECUTION_FAILED";
+}
+function promptFailureMessage(code, error) {
+    if (code === "PROMPT_DECRYPT_FAILED") {
+        return "Failed to decrypt the prompt for this daemon. Re-pair the daemon with the correct account secret.";
+    }
+    if (code === "MEMORY_OPTIONS_DECRYPT_FAILED") {
+        return "Failed to decrypt memory options for this turn.";
+    }
+    return safeErrorMessage(error);
+}
+function isCryptoOperationFailure(error) {
+    const record = error && typeof error === "object" ? error : {};
+    const name = typeof record.name === "string" ? record.name : "";
+    const code = typeof record.code === "string" ? record.code : "";
+    const message = safeErrorMessage(error);
+    return name === "OperationError" ||
+        code === "ERR_OSSL_BAD_DECRYPT" ||
+        /operation-specific reason|decrypt|authentication tag|Unsupported state or unable to authenticate data/i.test(message);
+}
+function safeErrorMessage(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return String(error);
+}
 async function decryptMemoryOptions(config, command) {
     if (!command.encryptedMemoryOptions)
         return undefined;

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.86",
+  "version": "0.1.0-beta.87",
   "private": true,
   "type": "module"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.86",
+  "version": "0.1.0-beta.87",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {