@cydm/happy-elves 0.1.0-beta.289 → 0.1.0-beta.294

package/apps/cli/package.json

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

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

@@ -117,12 +117,13 @@ function releaseStages(release) {
         { name: "p0-release", command: "pnpm", args: ["verify:p0:release"], phase: "gate" },
         { name: "deploy-production", command: "pnpm", args: ["deploy:production"], phase: "deploy" },
         { name: "verify-deploy", command: "pnpm", args: ["verify:deploy"], phase: "verify" },
+        { name: "publish-package", command: "pnpm", args: ["publish:public"], phase: "publish" },
     ];
     for (const machineId of release.targetMachineIds ?? []) {
         stages.push({
             name: `daemon-update:${machineId}`,
             command: "happy-elves",
-            args: ["remote", "daemon-update", machineId, "--version", "latest", "--wait", "--json"],
+            args: ["remote", "daemon-update", machineId, "--version", "__PUBLIC_PACKAGE_VERSION__", "--wait", "--json"],
             phase: "update",
         });
     }
@@ -220,7 +221,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 
 const input = ${inputJson};
-const terminalStatuses = new Set(["gate_failed", "deploy_failed", "verify_failed", "update_failed", "notify_failed", "dogfood_failed", "succeeded", "failed"]);
+const terminalStatuses = new Set(["gate_failed", "deploy_failed", "verify_failed", "publish_failed", "update_failed", "notify_failed", "dogfood_failed", "succeeded", "failed"]);
 
 main().catch(async (error) => {
   await fail("failed", error);
@@ -230,6 +231,7 @@ main().catch(async (error) => {
 async function main() {
   await fs.mkdir(path.dirname(input.logPath), { recursive: true });
   await updateState({ status: "running", updatedAt: new Date().toISOString() });
+  input.publicPackageVersion = await publicPackageVersion();
   await log("release runner started " + JSON.stringify({ jobId: input.jobId, profile: input.release.profile.name, repoCwd: input.repoCwd }));
   for (const stage of input.stages) {
     await runStage(stage);
@@ -243,6 +245,7 @@ async function runStage(stage) {
   const args = stage.args.map((arg) => {
     if (arg === "__RELEASE_SUMMARY__") return releaseSummary("Release completed");
     if (arg === "__RELEASE_REVIEW_SUMMARY__") return releaseSummary("Release completed; please review the evidence");
+    if (arg === "__PUBLIC_PACKAGE_VERSION__") return input.publicPackageVersion;
     return arg;
   });
   await log("$ " + stage.command + " " + args.map(shellQuote).join(" "));
@@ -271,11 +274,19 @@ function statusForPhase(phase) {
   if (phase === "gate") return "gate_failed";
   if (phase === "deploy") return "deploy_failed";
   if (phase === "verify") return "verify_failed";
+  if (phase === "publish") return "publish_failed";
   if (phase === "update") return "update_failed";
   if (phase === "notify") return "notify_failed";
   return "failed";
 }
 
+async function publicPackageVersion() {
+  if (input.release.publicPackageVersion) return input.release.publicPackageVersion;
+  const result = await run("git", ["rev-list", "--count", "HEAD"], { cwd: input.repoCwd, env: process.env });
+  if (result.exitCode !== 0) throw new Error("failed to derive public package version: " + (result.stderr || result.stdout));
+  return "0.1.0-beta." + result.stdout.trim();
+}
+
 async function fail(status, error) {
   const message = error instanceof Error ? error.stack || error.message : String(error);
   await log("release runner failed: " + message).catch(() => {});
@@ -306,6 +317,10 @@ function envForStage(stage) {
     delete env.HAPPY_ELVES_RELAY_URL;
     delete env.HAPPY_ELVES_CONTROLLER_TOKEN;
     delete env.HAPPY_ELVES_ACCOUNT_SECRET;
+    if (stage.phase !== "publish") {
+      delete env.NPM_TOKEN;
+      delete env.NODE_AUTH_TOKEN;
+    }
     return env;
   }
   const config = input.controllerConfig;

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

@@ -263,6 +263,7 @@ export async function handleFork(ws, config, command) {
             sourceSessionId: command.sessionId,
             sourceCheckpointId,
         }),
+        controllerEncryptedMetadata: command.controllerEncryptedMetadata,
     });
     if (authoritativeForkTranscript) {
         try {

package/apps/daemon/package.json

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

package/apps/relay/dist/controller-handlers.js

@@ -112,8 +112,8 @@ export function handleControllerMessage(context, connection, message) {
         db.exec("BEGIN");
         try {
             db.prepare(`INSERT INTO sessions
-         (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, connection.accountId, message.machineId, message.agent, message.cwd, message.name, "new", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, createdAt, createdAt);
+         (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, controller_encrypted_metadata, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, connection.accountId, message.machineId, message.agent, message.cwd, message.name, "new", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, message.controllerEncryptedMetadata ? JSON.stringify(message.controllerEncryptedMetadata) : null, createdAt, createdAt);
             db.prepare(`INSERT INTO relay_admissions
          (account_id, request_id, session_id, machine_id, kind, turn_id, admission, dispatch, created_at, updated_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(connection.accountId, message.requestId, sessionId, message.machineId, "createSession", null, "accepted", "queued", createdAt, createdAt);
@@ -251,8 +251,10 @@ export function handleControllerMessage(context, connection, message) {
             return;
         const updatedAt = now();
         db.prepare(`UPDATE sessions
-       SET encrypted_metadata = ?, updated_at = ?
-       WHERE id = ? AND account_id = ?`).run(JSON.stringify(message.encryptedMetadata), updatedAt, sessionRow.id, connection.accountId);
+       SET encrypted_metadata = ?,
+           controller_encrypted_metadata = COALESCE(?, controller_encrypted_metadata),
+           updated_at = ?
+       WHERE id = ? AND account_id = ?`).run(JSON.stringify(message.encryptedMetadata), message.controllerEncryptedMetadata ? JSON.stringify(message.controllerEncryptedMetadata) : null, updatedAt, sessionRow.id, connection.accountId);
         const updated = sessionSnapshot(db.prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ?").get(sessionRow.id, connection.accountId));
         broadcastControllers(connection.accountId, { type: "server:session", session: updated });
         sendAck(connection, {
@@ -677,8 +679,8 @@ export function handleControllerMessage(context, connection, message) {
         const sessionId = randomId("ses");
         const createdAt = now();
         db.prepare(`INSERT INTO sessions
-       (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, connection.accountId, message.machineId, message.agent, message.cwd, message.name, "new", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, createdAt, createdAt);
+       (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, controller_encrypted_metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, connection.accountId, message.machineId, message.agent, message.cwd, message.name, "new", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, message.controllerEncryptedMetadata ? JSON.stringify(message.controllerEncryptedMetadata) : null, createdAt, createdAt);
         const session = sessionSnapshot(db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId));
         broadcastControllers(connection.accountId, { type: "server:session", session });
         markCommandPending(connection.accountId, message.machineId, message.requestId);
@@ -749,6 +751,7 @@ export function handleControllerMessage(context, connection, message) {
             name: message.name,
             sourceEncryptedMetadata: sessionRow.encrypted_metadata ? parseJson(sessionRow.encrypted_metadata, undefined) : undefined,
             encryptedMetadata: message.encryptedMetadata,
+            controllerEncryptedMetadata: message.controllerEncryptedMetadata,
         });
         return;
     }

package/apps/relay/dist/db.js

@@ -61,6 +61,7 @@ export function initDb(db) {
       name TEXT NOT NULL,
       status TEXT NOT NULL,
       encrypted_metadata TEXT,
+      controller_encrypted_metadata TEXT,
       current_head TEXT,
       last_turn_id TEXT,
       head_basis_event_id INTEGER,
@@ -291,6 +292,7 @@ export function initDb(db) {
     ensureColumn(db, "relay_admissions", "started_at", "INTEGER");
     ensureColumn(db, "relay_admissions", "finished_at", "INTEGER");
     ensureColumn(db, "relay_admissions", "terminal_status", "TEXT");
+    ensureColumn(db, "sessions", "controller_encrypted_metadata", "TEXT");
     ensureColumn(db, "relay_admissions", "last_error_code", "TEXT");
     ensureColumn(db, "relay_dispatch_outbox", "message", "TEXT");
     ensureColumn(db, "relay_dispatch_outbox", "command_type", "TEXT");

package/apps/relay/dist/http-routes.js

@@ -77,6 +77,7 @@ function sessionEventLogicalSeqValue(row) {
 }
 function canonicalEventRows(context, accountId, rows) {
     const cache = new Map();
+    const suppressCache = new Map();
     const seenHistorical = new Set();
     const canonicalRows = [];
     for (const row of rows) {
@@ -90,6 +91,20 @@ function canonicalEventRows(context, accountId, rows) {
             requestTurnId = alias?.request_turn_id ?? null;
             cache.set(key, requestTurnId);
         }
+        if (requestTurnId) {
+            let suppress = suppressCache.get(key);
+            if (suppress === undefined) {
+                suppress = context.aliasedRuntimeEventHasRequestEvents({
+                    accountId,
+                    sessionId: row.session_id,
+                    machineId: row.machine_id,
+                    runtimeTurnId: row.turn_id,
+                });
+                suppressCache.set(key, suppress);
+            }
+            if (suppress)
+                continue;
+        }
         const canonicalRow = requestTurnId ? { ...row, turn_id: requestTurnId } : row;
         const historicalKey = canonicalHistoricalEventKey(canonicalRow);
         if (historicalKey) {
@@ -284,8 +299,8 @@ export function registerHttpRoutes(app, context, controllerInviteTtlMs) {
         context.db.exec("BEGIN");
         try {
             context.db.prepare(`INSERT INTO sessions
-         (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, token.account_id, token.machine_id, body.agent, body.cwd, body.name, "new", body.encryptedMetadata ? JSON.stringify(body.encryptedMetadata) : null, createdAt, createdAt);
+         (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, controller_encrypted_metadata, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, token.account_id, token.machine_id, body.agent, body.cwd, body.name, "new", body.encryptedMetadata ? JSON.stringify(body.encryptedMetadata) : null, body.controllerEncryptedMetadata ? JSON.stringify(body.controllerEncryptedMetadata) : null, createdAt, createdAt);
             context.db.prepare(`INSERT INTO relay_admissions
          (account_id, request_id, session_id, machine_id, kind, turn_id, admission, dispatch, created_at, updated_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(token.account_id, body.requestId, sessionId, token.machine_id, "createSession", null, "accepted", "queued", createdAt, createdAt);

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

@@ -148,6 +148,19 @@ export declare const machineCreateSessionAdmissionSchema: z.ZodObject<{
             ciphertext: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
+    controllerEncryptedMetadata: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        alg: z.ZodLiteral<"A256GCM">;
+        scope: z.ZodString;
+        key: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const machinePromptAdmissionSchema: z.ZodObject<{
     requestId: z.ZodString;

package/apps/relay/dist/http-schemas.js

@@ -124,6 +124,7 @@ export const machineCreateSessionAdmissionSchema = z.object({
     name: z.string().min(1),
     model: z.string().min(1).optional(),
     encryptedMetadata: encryptedEnvelopeSchema.optional(),
+    controllerEncryptedMetadata: encryptedEnvelopeSchema.optional(),
 });
 export const machinePromptAdmissionSchema = z.object({
     requestId: z.string().min(1),

package/apps/relay/dist/machine-handlers.js

@@ -346,9 +346,9 @@ export function handleMachineMessage(context, connection, message) {
         }
         else {
             db.prepare(`INSERT INTO sessions
-         (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata,
+         (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, controller_encrypted_metadata,
           current_head, last_turn_id, source_session_id, source_checkpoint_id, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(message.sessionId, connection.accountId, connection.machineId, source.agent, source.cwd, message.name ?? source.name, message.transcriptPending === true ? "running" : "ready", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : source.encrypted_metadata, message.sourceCheckpointId, source.last_turn_id, message.sourceSessionId, message.sourceCheckpointId, ts, ts);
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(message.sessionId, connection.accountId, connection.machineId, source.agent, source.cwd, message.name ?? source.name, message.transcriptPending === true ? "running" : "ready", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : source.encrypted_metadata, message.controllerEncryptedMetadata ? JSON.stringify(message.controllerEncryptedMetadata) : null, message.sourceCheckpointId, source.last_turn_id, message.sourceSessionId, message.sourceCheckpointId, ts, ts);
         }
         const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row)
@@ -532,7 +532,10 @@ export function handleMachineMessage(context, connection, message) {
             broadcastControllers(connection.accountId, {
                 type: "server:sessionTranscriptReplaced",
                 session,
-                events: inserted.map((event) => canonicalEventForControllers(db, connection.accountId, event)),
+                events: inserted.flatMap((event) => {
+                    const canonicalEvent = canonicalEventForControllers(db, connection.accountId, event);
+                    return canonicalEvent ? [canonicalEvent] : [];
+                }),
                 hasMoreBefore: message.hasMoreBefore,
                 nextBefore: message.nextBefore,
             });
@@ -601,7 +604,10 @@ export function handleMachineMessage(context, connection, message) {
             broadcastControllers(connection.accountId, {
                 type: "server:sessionTranscriptPrepended",
                 session,
-                events: inserted,
+                events: inserted.flatMap((event) => {
+                    const canonicalEvent = canonicalEventForControllers(db, connection.accountId, event);
+                    return canonicalEvent ? [canonicalEvent] : [];
+                }),
                 hasMoreBefore: message.hasMoreBefore,
                 nextBefore: message.nextBefore,
             });
@@ -619,20 +625,6 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
-        const activeClaim = sessionBefore
-            ? activePromptClaim(db, connection.accountId, message.sessionId, connection.machineId)
-            : undefined;
-        if (sessionBefore?.status === "running" && activeClaim && message.status) {
-            recordAliasesForRuntimeTurnIds({
-                accountId: connection.accountId,
-                sessionId: message.sessionId,
-                machineId: connection.machineId,
-                requestTurnId: activeClaim.turn_id,
-                requestId: activeClaim.request_id,
-                runtimeTurnIds: [message.lastTurnId, message.currentHead, message.basis.turnId],
-                recordTurnAlias,
-            });
-        }
         const input = {
             accountId: connection.accountId,
             sessionId: message.sessionId,
@@ -673,21 +665,6 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
-        if (message.status && activeClaim && sessionBefore?.status === "running") {
-            db.prepare(`UPDATE sessions
-         SET status = ?,
-             last_turn_id = COALESCE(?, last_turn_id),
-             updated_at = ?
-         WHERE id = ? AND account_id = ? AND machine_id = ? AND status = 'running'`).run(message.status, message.lastTurnId ?? message.currentHead ?? message.basis.turnId, ts, message.sessionId, connection.accountId, connection.machineId);
-            finishSessionClaim({
-                accountId: connection.accountId,
-                sessionId: message.sessionId,
-                requestId: activeClaim.request_id,
-                turnId: activeClaim.turn_id,
-                terminalStatus: message.status,
-                finishedAt: ts,
-            });
-        }
         const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row)
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
@@ -704,17 +681,6 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
-        maybeAliasHistoricalRuntimeEventToActiveClaim({
-            db,
-            accountId: connection.accountId,
-            sessionId: message.sessionId,
-            machineId: connection.machineId,
-            session: sessionRow,
-            turnId: message.turnId,
-            messageId: message.messageId,
-            occurredAt: message.occurredAt,
-            recordTurnAlias,
-        });
         const event = insertEvent({
             accountId: connection.accountId,
             sessionId: message.sessionId,
@@ -727,7 +693,9 @@ export function handleMachineMessage(context, connection, message) {
             payload: message.payload,
         });
         const pendingSessionRow = applyPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId, now());
-        broadcastControllers(connection.accountId, { type: "server:event", event: canonicalEventForControllers(db, connection.accountId, event) });
+        const canonicalEvent = canonicalEventForControllers(db, connection.accountId, event);
+        if (canonicalEvent)
+            broadcastControllers(connection.accountId, { type: "server:event", event: canonicalEvent });
         if (pendingSessionRow)
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(pendingSessionRow) });
         acknowledgeMachineMessage();
@@ -943,7 +911,15 @@ function applySessionHeadAdvance(db, input, ts) {
         sessionRow.current_head === input.currentHead ||
         sessionRow.last_turn_id === input.lastTurnId;
     const shouldAdvance = !rewriteFenced && (comparison > 0 || (comparison === 0 && currentHeadIsBasisEvent));
+    const activeClaim = activePromptClaim(db, input.accountId, input.sessionId, input.machineId);
+    const activeClaimOwnsHeadAdvance = !activeClaim ||
+        input.basis.turnId === activeClaim.turn_id ||
+        input.currentHead === activeClaim.turn_id ||
+        input.lastTurnId === activeClaim.turn_id;
+    if (!activeClaimOwnsHeadAdvance)
+        return { status: "noop", session: sessionRow };
     const shouldSettleStatus = !rewriteFenced &&
+        !activeClaim &&
         input.status !== undefined &&
         sessionRow.status === "running" &&
         comparison === 0 &&
@@ -960,7 +936,7 @@ function applySessionHeadAdvance(db, input, ts) {
          head_basis_turn_seq = COALESCE(?, head_basis_turn_seq),
          encrypted_metadata = COALESCE(?, encrypted_metadata),
          updated_at = ?
-     WHERE id = ? AND account_id = ? AND machine_id = ?`).run(input.status && sessionRow.status === "running" ? input.status : null, shouldAdvance ? input.currentHead : null, shouldAdvance ? input.lastTurnId : null, shouldAdvance ? basisEvent.id : null, shouldAdvance ? basisEvent.message_id : null, shouldAdvance ? nextOrder.time : null, shouldAdvance ? nextOrder.seq : null, input.encryptedMetadata ? JSON.stringify(input.encryptedMetadata) : null, ts, input.sessionId, input.accountId, input.machineId);
+     WHERE id = ? AND account_id = ? AND machine_id = ?`).run(shouldSettleStatus ? input.status ?? null : null, shouldAdvance ? input.currentHead : null, shouldAdvance ? input.lastTurnId : null, shouldAdvance ? basisEvent.id : null, shouldAdvance ? basisEvent.message_id : null, shouldAdvance ? nextOrder.time : null, shouldAdvance ? nextOrder.seq : null, input.encryptedMetadata ? JSON.stringify(input.encryptedMetadata) : null, ts, input.sessionId, input.accountId, input.machineId);
     const session = db.prepare("SELECT * FROM sessions WHERE id = ?").get(input.sessionId);
     return { status: "applied", session };
 }
@@ -1061,29 +1037,6 @@ function promptTurnForRequestId(db, accountId, sessionId, machineId, requestId)
        LIMIT 1`)
         .get(accountId, sessionId, machineId, requestId);
 }
-function maybeAliasHistoricalRuntimeEventToActiveClaim(input) {
-    if (input.session.status !== "running")
-        return;
-    if (!isHistoricalRuntimeBackfillMessage(input.messageId, input.occurredAt))
-        return;
-    const claim = activePromptClaim(input.db, input.accountId, input.sessionId, input.machineId);
-    if (!claim)
-        return;
-    recordAliasesForRuntimeTurnIds({
-        accountId: input.accountId,
-        sessionId: input.sessionId,
-        machineId: input.machineId,
-        requestTurnId: claim.turn_id,
-        requestId: claim.request_id,
-        runtimeTurnIds: [input.turnId],
-        recordTurnAlias: input.recordTurnAlias,
-    });
-}
-function isHistoricalRuntimeBackfillMessage(messageId, occurredAt) {
-    if (messageId?.startsWith("hist_") || messageId?.startsWith("tail_"))
-        return true;
-    return occurredAt !== undefined;
-}
 function recordAliasesForRuntimeTurnIds(input) {
     for (const runtimeTurnId of input.runtimeTurnIds) {
         if (!isRuntimeTurnAliasCandidate(input.requestTurnId, runtimeTurnId))
@@ -1114,8 +1067,33 @@ function canonicalEventForControllers(db, accountId, event) {
        WHERE account_id = ? AND session_id = ? AND machine_id = ? AND runtime_turn_id = ?
        LIMIT 1`)
         .get(accountId, event.sessionId, event.machineId, event.turnId);
-    return alias && alias.request_turn_id !== event.turnId
-        ? { ...event, turnId: alias.request_turn_id }
-        : event;
+    if (!alias || alias.request_turn_id === event.turnId)
+        return event;
+    if (aliasedRuntimeEventHasRequestEvents(db, {
+        accountId,
+        sessionId: event.sessionId,
+        machineId: event.machineId,
+        runtimeTurnId: event.turnId,
+    })) {
+        return undefined;
+    }
+    return { ...event, turnId: alias.request_turn_id };
+}
+function aliasedRuntimeEventHasRequestEvents(db, params) {
+    const alias = db
+        .prepare(`SELECT request_turn_id FROM session_turn_aliases
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND runtime_turn_id = ?
+       LIMIT 1`)
+        .get(params.accountId, params.sessionId, params.machineId, params.runtimeTurnId);
+    if (!alias || alias.request_turn_id === params.runtimeTurnId)
+        return false;
+    const existing = db
+        .prepare(`SELECT COUNT(*) AS count FROM (
+         SELECT 1 FROM session_events
+         WHERE account_id = ? AND session_id = ? AND machine_id = ? AND turn_id = ?
+         LIMIT 3
+       )`)
+        .get(params.accountId, params.sessionId, params.machineId, alias.request_turn_id);
+    return (existing?.count ?? 0) >= 3;
 }
 //# sourceMappingURL=machine-handlers.js.map

package/apps/relay/dist/projections.js

@@ -149,6 +149,7 @@ export function sessionSnapshot(row, capabilitiesForMachine, historyModelForMach
         createdAt: row.created_at,
         updatedAt: row.updated_at,
         encryptedMetadata: parseJson(row.encrypted_metadata, undefined),
+        controllerEncryptedMetadata: parseJson(row.controller_encrypted_metadata, undefined),
         currentHead: row.current_head ?? undefined,
         lastTurnId: row.last_turn_id ?? undefined,
         headBasis: sessionHeadBasis(row),

package/apps/relay/dist/relay-context.js

@@ -571,6 +571,9 @@ export function createRelayContext(options) {
         const currentHead = session?.current_head;
         if (session?.status === "closed")
             return false;
+        if (session?.status === "running" && params.source === "machine" && session.last_turn_id && params.turnId !== session.last_turn_id) {
+            return false;
+        }
         if (!currentHead)
             return true;
         if (typeof session?.head_basis_message_id === "string" &&
@@ -578,9 +581,6 @@ export function createRelayContext(options) {
             params.source === "machine") {
             return false;
         }
-        if (session?.status === "running" && params.source === "machine" && session.last_turn_id && params.turnId !== session.last_turn_id) {
-            return false;
-        }
         const nextOrder = logicalEventOrder({
             id: eventId,
             createdAt,

package/apps/relay/dist/types.d.ts

@@ -40,6 +40,7 @@ export type SessionRow = {
     name: string;
     status: SessionSnapshot["status"];
     encrypted_metadata: string | null;
+    controller_encrypted_metadata: string | null;
     current_head: string | null;
     last_turn_id: string | null;
     head_basis_event_id: number | null;

package/package.json

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

package/packages/client/dist/client.js

@@ -1,4 +1,4 @@
-import { decryptJson, encryptJson, normalizeSessionTags, normalizeSessionName, sessionTagsMatch, parseServerMessage, randomId, } from "../../shared/dist/index.js";
+import { decryptJson, encryptJson, normalizeSessionTags, sessionTagKeys, normalizeSessionName, sessionTagsMatch, parseServerMessage, randomId, } from "../../shared/dist/index.js";
 import { addControllerDevice, claimControllerInvite, createControllerInvite, createPairingCode, createScopedToken, deleteMemory as deleteMemoryRecord, listDevices, listEncryptedMemories, listMemorySettings, renameDevice, markSessionRecent, pinWorkspaceCwd, listScopedTokens, revokeDevice, revokeScopedToken, saveEncryptedMemory, setSessionStar, setMemorySettings, setWorkspaceProjectPreference, tokenSelf, unpinWorkspaceCwd, workspaceSyncState, } from "./account.js";
 import { ControllerClientError, ControllerCommandError } from "./errors.js";
 import { authenticatedJson, normalizeRelayUrl, readRelayJson, relayHttpError } from "./http.js";
@@ -30,6 +30,11 @@ function runtimeSessionIdsForMetadata(metadata) {
 function isCanonicalRuntimeSessionCandidate(left, right) {
     return left.createdAt < right.createdAt || (left.createdAt === right.createdAt && left.id < right.id);
 }
+function controllerSessionMetadata(tags) {
+    if (tags.length === 0)
+        return undefined;
+    return { tags, tagKeys: sessionTagKeys(tags) };
+}
 function runSettlementTimeoutMs(options) {
     if (options.waitTimeoutMs !== undefined)
         return options.waitTimeoutMs;
@@ -226,6 +231,7 @@ export class ControllerClient {
         const requestedRuntimeName = input.runtimeName === undefined ? undefined : normalizeSessionName(input.runtimeName);
         const model = normalizeOptionalString(input.model);
         const tags = normalizeSessionTags(input.tags);
+        const controllerMetadata = controllerSessionMetadata(tags);
         const requestId = randomId("req");
         const result = await this.sendCommand({
             type: "controller:createSession",
@@ -246,29 +252,34 @@ export class ControllerClient {
                 ...(input.hiddenFromWorkspace ? { hiddenFromWorkspace: true, visibility: "hidden" } : {}),
                 permissionMode: input.permissionMode,
                 ...(input.source ? { source: input.source } : {}),
-                ...(tags.length > 0 ? { tags, tagKeys: tags.map((tag) => tag.trim().replace(/\s+/gu, " ").toLocaleLowerCase()) } : {}),
+                ...(tags.length > 0 ? { tags, tagKeys: sessionTagKeys(tags) } : {}),
             }),
+            ...(controllerMetadata ? {
+                controllerEncryptedMetadata: await encryptJson(this.config.accountSecret, `session:controller-metadata:create:${requestId}`, controllerMetadata),
+            } : {}),
         });
         return { ...result, requestId };
     }
     async updateSessionMetadata(input) {
         const sessionId = requireNonEmpty(input.sessionId, "sessionId");
         const requestId = randomId("req");
-        const metadata = { ...input.metadata };
-        const tags = normalizeSessionTags(metadata.tags);
+        const tags = normalizeSessionTags(input.metadata.tags);
+        const runtimeMetadata = { ...input.metadata };
         if (tags.length > 0) {
-            metadata.tags = tags;
-            metadata.tagKeys = tags.map((tag) => tag.trim().replace(/\s+/gu, " ").toLocaleLowerCase());
+            runtimeMetadata.tags = tags;
+            runtimeMetadata.tagKeys = sessionTagKeys(tags);
         }
         else {
-            delete metadata.tags;
-            delete metadata.tagKeys;
+            delete runtimeMetadata.tags;
+            delete runtimeMetadata.tagKeys;
         }
+        const controllerMetadata = controllerSessionMetadata(tags) ?? {};
         const result = await this.sendCommand({
             type: "controller:updateSessionMetadata",
             requestId,
             sessionId,
-            encryptedMetadata: await encryptJson(this.config.accountSecret, `session:${sessionId}:metadata:update:${requestId}`, metadata),
+            encryptedMetadata: await encryptJson(this.config.accountSecret, `session:${sessionId}:metadata:update:${requestId}`, runtimeMetadata),
+            controllerEncryptedMetadata: await encryptJson(this.config.accountSecret, `session:${sessionId}:controller-metadata:update:${requestId}`, controllerMetadata),
         });
         return { requestId, sessionId: result.sessionId ?? sessionId };
     }
@@ -573,6 +584,7 @@ export class ControllerClient {
         const from = requireNonEmpty(input.from, "from");
         const name = requireNonEmpty(input.name, "name");
         const tags = normalizeSessionTags(input.tags);
+        const controllerMetadata = controllerSessionMetadata(tags);
         const requestId = randomId("req");
         return await this.sendCommand({
             type: "controller:fork",
@@ -584,8 +596,11 @@ export class ControllerClient {
                 sourceSessionId: checkedSessionId,
                 from,
                 name,
-                ...(tags.length > 0 ? { tags, tagKeys: tags.map((tag) => tag.trim().replace(/\s+/gu, " ").toLocaleLowerCase()) } : {}),
+                ...(tags.length > 0 ? { tags, tagKeys: sessionTagKeys(tags) } : {}),
             }),
+            ...(controllerMetadata ? {
+                controllerEncryptedMetadata: await encryptJson(this.config.accountSecret, `session:fork:${requestId}:controller-metadata`, controllerMetadata),
+            } : {}),
         });
     }
     async renameSession(sessionId, name) {
@@ -700,14 +715,33 @@ export class ControllerClient {
         }
     }
     async decodeSessionMetadata(session) {
-        if (!session.encryptedMetadata)
-            return {};
+        let runtimeMetadata = {};
+        let controllerMetadata = {};
         try {
-            return await decryptJson(this.config.accountSecret, session.encryptedMetadata);
+            if (session.encryptedMetadata)
+                runtimeMetadata = await decryptJson(this.config.accountSecret, session.encryptedMetadata);
         }
         catch {
-            return {};
+            runtimeMetadata = {};
+        }
+        try {
+            if (session.controllerEncryptedMetadata)
+                controllerMetadata = await decryptJson(this.config.accountSecret, session.controllerEncryptedMetadata);
+        }
+        catch {
+            controllerMetadata = {};
+        }
+        const merged = { ...runtimeMetadata, ...controllerMetadata };
+        const tags = normalizeSessionTags(controllerMetadata.tags ?? runtimeMetadata.tags);
+        if (tags.length > 0) {
+            merged.tags = tags;
+            merged.tagKeys = sessionTagKeys(tags);
+        }
+        else {
+            delete merged.tags;
+            delete merged.tagKeys;
         }
+        return merged;
     }
     async decodeMemory(memory) {
         const payload = await decryptJson(this.config.accountSecret, memory.encryptedMemory);

package/packages/shared/dist/protocol-schemas.d.ts

@@ -233,6 +233,19 @@ export declare const sessionSnapshotSchema: z.ZodObject<{
             ciphertext: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
+    controllerEncryptedMetadata: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        alg: z.ZodLiteral<"A256GCM">;
+        scope: z.ZodString;
+        key: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+        data: z.ZodObject<{
+            nonce: z.ZodString;
+            ciphertext: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
     currentHead: z.ZodOptional<z.ZodString>;
     lastTurnId: z.ZodOptional<z.ZodString>;
     headBasis: z.ZodOptional<z.ZodObject<{
@@ -563,6 +576,7 @@ export declare const releaseJobResultSchema: z.ZodObject<{
         gate_failed: "gate_failed";
         deploy_failed: "deploy_failed";
         verify_failed: "verify_failed";
+        publish_failed: "publish_failed";
         update_failed: "update_failed";
         notify_failed: "notify_failed";
         dogfood_failed: "dogfood_failed";

package/packages/shared/dist/protocol-schemas.js

@@ -83,6 +83,7 @@ export const sessionSnapshotSchema = z.object({
     createdAt: z.number(),
     updatedAt: z.number(),
     encryptedMetadata: encryptedEnvelopeSchema.optional(),
+    controllerEncryptedMetadata: encryptedEnvelopeSchema.optional(),
     currentHead: z.string().min(1).optional(),
     lastTurnId: z.string().min(1).optional(),
     headBasis: z.object({
@@ -260,7 +261,7 @@ export const releaseJobResultSchema = z.object({
     action: z.enum(["start", "status", "logs"]),
     accepted: z.boolean().optional(),
     jobId: z.string().min(1).optional(),
-    status: z.enum(["accepted", "running", "gate_failed", "deploy_failed", "verify_failed", "update_failed", "notify_failed", "dogfood_failed", "succeeded", "failed"]).optional(),
+    status: z.enum(["accepted", "running", "gate_failed", "deploy_failed", "verify_failed", "publish_failed", "update_failed", "notify_failed", "dogfood_failed", "succeeded", "failed"]).optional(),
     profileName: z.string().min(1).optional(),
     releaseSessionId: z.string().min(1).optional(),
     machineId: z.string().min(1).optional(),

package/packages/shared/dist/protocol-types.d.ts

@@ -61,6 +61,7 @@ export type SessionSnapshot = {
     createdAt: number;
     updatedAt: number;
     encryptedMetadata?: EncryptedEnvelope;
+    controllerEncryptedMetadata?: EncryptedEnvelope;
     currentHead?: string;
     lastTurnId?: string;
     headBasis?: {
@@ -209,7 +210,7 @@ export type DaemonLifecycleResult = {
     updateState?: DaemonUpdateState;
     logs?: string[];
 };
-export type ReleaseJobStage = "accepted" | "running" | "gate_failed" | "deploy_failed" | "verify_failed" | "update_failed" | "notify_failed" | "dogfood_failed" | "succeeded" | "failed";
+export type ReleaseJobStage = "accepted" | "running" | "gate_failed" | "deploy_failed" | "verify_failed" | "publish_failed" | "update_failed" | "notify_failed" | "dogfood_failed" | "succeeded" | "failed";
 export type ReleaseProfile = {
     name: string;
     releaseSessionTags: string[];

package/packages/shared/dist/protocol.d.ts

@@ -11,6 +11,7 @@ export type ControllerClientMessage = {
     name: string;
     model?: string;
     encryptedMetadata?: EncryptedEnvelope;
+    controllerEncryptedMetadata?: EncryptedEnvelope;
 } | {
     type: "controller:prompt";
     requestId: string;
@@ -33,6 +34,7 @@ export type ControllerClientMessage = {
     requestId: string;
     sessionId: string;
     encryptedMetadata: EncryptedEnvelope;
+    controllerEncryptedMetadata?: EncryptedEnvelope;
 } | {
     type: "controller:optionResponse";
     requestId: string;
@@ -142,6 +144,7 @@ export type ControllerClientMessage = {
     runtimeSessionId: string;
     name: string;
     encryptedMetadata?: EncryptedEnvelope;
+    controllerEncryptedMetadata?: EncryptedEnvelope;
 } | {
     type: "controller:rewind";
     requestId: string;
@@ -154,6 +157,7 @@ export type ControllerClientMessage = {
     from: string;
     name: string;
     encryptedMetadata?: EncryptedEnvelope;
+    controllerEncryptedMetadata?: EncryptedEnvelope;
 } | {
     type: "controller:renameSession";
     requestId: string;
@@ -311,6 +315,7 @@ export type MachineClientMessage = {
     messageId?: string;
     transcriptPending?: boolean;
     encryptedMetadata?: EncryptedEnvelope;
+    controllerEncryptedMetadata?: EncryptedEnvelope;
 } | {
     type: "machine:sessionRenamed";
     requestId: string;
@@ -493,6 +498,7 @@ export type MachineCommand = {
     name: string;
     sourceEncryptedMetadata?: EncryptedEnvelope;
     encryptedMetadata?: EncryptedEnvelope;
+    controllerEncryptedMetadata?: EncryptedEnvelope;
 } | {
     type: "machine:renameSession";
     requestId: string;

package/packages/shared/dist/protocol.js

@@ -12,6 +12,7 @@ const controllerMessageSchema = z.discriminatedUnion("type", [
         name: z.string().min(1),
         model: z.string().min(1).optional(),
         encryptedMetadata: encryptedEnvelopeSchema.optional(),
+        controllerEncryptedMetadata: encryptedEnvelopeSchema.optional(),
     }),
     z.object({
         type: z.literal("controller:prompt"),
@@ -37,6 +38,7 @@ const controllerMessageSchema = z.discriminatedUnion("type", [
         requestId: z.string().min(1),
         sessionId: z.string().min(1),
         encryptedMetadata: encryptedEnvelopeSchema,
+        controllerEncryptedMetadata: encryptedEnvelopeSchema.optional(),
     }),
     z.object({
         type: z.literal("controller:optionResponse"),
@@ -160,6 +162,7 @@ const controllerMessageSchema = z.discriminatedUnion("type", [
         runtimeSessionId: z.string().min(1),
         name: z.string().min(1),
         encryptedMetadata: encryptedEnvelopeSchema.optional(),
+        controllerEncryptedMetadata: encryptedEnvelopeSchema.optional(),
     }),
     z.object({
         type: z.literal("controller:rewind"),
@@ -174,6 +177,7 @@ const controllerMessageSchema = z.discriminatedUnion("type", [
         from: z.string().min(1),
         name: z.string().min(1),
         encryptedMetadata: encryptedEnvelopeSchema.optional(),
+        controllerEncryptedMetadata: encryptedEnvelopeSchema.optional(),
     }),
     z.object({
         type: z.literal("controller:renameSession"),
@@ -372,6 +376,7 @@ const machineMessageSchema = z.discriminatedUnion("type", [
         messageId: z.string().min(1).optional(),
         transcriptPending: z.boolean().optional(),
         encryptedMetadata: encryptedEnvelopeSchema.optional(),
+        controllerEncryptedMetadata: encryptedEnvelopeSchema.optional(),
     }),
     z.object({
         type: z.literal("machine:sessionRenamed"),
@@ -580,6 +585,7 @@ const machineCommandSchema = z.discriminatedUnion("type", [
         name: z.string().min(1),
         sourceEncryptedMetadata: encryptedEnvelopeSchema.optional(),
         encryptedMetadata: encryptedEnvelopeSchema.optional(),
+        controllerEncryptedMetadata: encryptedEnvelopeSchema.optional(),
     }),
     z.object({
         type: z.literal("machine:renameSession"),