chore: preserve additional local work before PR merges

Author: Shaw

packages/agent/src/runtime/eliza.ts

@@ -1717,6 +1717,7 @@ function resolveDefaultPgliteDataDir(config: ElizaConfig): string {
 export function applyDatabaseConfigToEnv(config: ElizaConfig): void {
   const db = config.database;
   const provider = db?.provider ?? "pglite";
+  const databaseUrl = process.env.DATABASE_URL?.trim();
 
   if (provider === "postgres" && db?.postgres) {
     const pg = db.postgres;
@@ -1734,6 +1735,10 @@ export function applyDatabaseConfigToEnv(config: ElizaConfig): void {
     process.env.POSTGRES_URL = url;
     // Clear PGLite dir so plugin-sql does not fall back to PGLite
     delete process.env.PGLITE_DATA_DIR;
+  } else if (!db?.provider && databaseUrl && !process.env.POSTGRES_URL) {
+    process.env.POSTGRES_URL = databaseUrl;
+    delete process.env.PGLITE_DATA_DIR;
+    logger.info("[eliza] DATABASE_URL detected: using Postgres database");
   } else {
     // PGLite mode (default): ensure no leftover POSTGRES_URL and pin
     // PGLite to the workspace path unless overridden by config/env.

packages/app-core/src/entry.ts

@@ -35,6 +35,20 @@ if (
   );
 }
 
+// Bridge DATABASE_URL → POSTGRES_URL. Cloud provisioners (docker-sandbox-provider,
+// k8s manifests, Railway env) inject DATABASE_URL, but plugin-sql reads
+// POSTGRES_URL via runtime.getSetting("POSTGRES_URL"). Without this bridge,
+// sandboxes silently fall back to PGLite at /root/.eliza/.elizadb instead of
+// connecting to the injected Neon database — losing all memories on container
+// restart and breaking memory transfer / centralized observability.
+if (process.env.DATABASE_URL && !process.env.POSTGRES_URL) {
+  process.env.POSTGRES_URL = process.env.DATABASE_URL;
+  // Stderr only — logger isn't initialized yet at this point in boot.
+  process.stderr.write(
+    "[entry] DATABASE_URL detected: bridged to POSTGRES_URL for plugin-sql\n",
+  );
+}
+
 // Keep `npx elizaai` startup readable by default.
 // This runs before CLI/runtime imports so @elizaos/core logger picks it up.
 if (!process.env.LOG_LEVEL) {

packages/app-core/src/services/voice-profiles/index.ts

@@ -0,0 +1,32 @@
+export type {
+  DiarizationSegment,
+  OwnerChallenge,
+  OwnerConfidence,
+  VoiceEmbeddingSummary,
+  VoiceProfile,
+  VoiceProfileQuality,
+} from "./types.ts";
+export {
+  InMemoryVoiceProfileStore,
+} from "./store.ts";
+export type { VoiceProfileSearchHit, VoiceProfileStore } from "./store.ts";
+export {
+  MOCK_DIARIZATION_PIPELINE,
+} from "./diarization-pipeline.ts";
+export type { DiarizationPipeline } from "./diarization-pipeline.ts";
+export { scoreOwnerConfidence } from "./owner-confidence.ts";
+export type { OwnerConfidenceInput } from "./owner-confidence.ts";
+export {
+  InMemoryChallengeService,
+} from "./private-challenge.ts";
+export type {
+  ChallengeService,
+  InMemoryChallengeServiceOptions,
+} from "./private-challenge.ts";
+export {
+  NAIVE_NICKNAME_EVALUATOR,
+} from "./nickname-evaluator.ts";
+export type {
+  NicknameEvaluator,
+  NicknameProposal,
+} from "./nickname-evaluator.ts";

packages/app-core/src/services/voice-profiles/nickname-evaluator.ts

@@ -0,0 +1,65 @@
+export interface NicknameProposal {
+  nickname: string;
+  subject: "owner" | "household";
+  confidence: number;
+  supportingTranscriptId: string;
+}
+
+export interface NicknameEvaluator {
+  evaluate(
+    transcript: { id: string; text: string }[],
+  ): Promise<NicknameProposal[]>;
+}
+
+interface NicknamePattern {
+  regex: RegExp;
+  subject: "owner" | "household";
+  confidence: number;
+}
+
+const PATTERNS: NicknamePattern[] = [
+  {
+    regex: /\bcall me ([A-Z][a-zA-Z'\- ]{0,30})\b/,
+    subject: "owner",
+    confidence: 0.85,
+  },
+  {
+    regex: /\bmy name is ([A-Z][a-zA-Z'\- ]{0,30})\b/,
+    subject: "owner",
+    confidence: 0.95,
+  },
+  {
+    regex: /\bI go by ([A-Z][a-zA-Z'\- ]{0,30})\b/,
+    subject: "owner",
+    confidence: 0.8,
+  },
+];
+
+function trimNickname(raw: string): string {
+  return raw.replace(/[\s.,!?;:]+$/, "").trim();
+}
+
+export const NAIVE_NICKNAME_EVALUATOR: NicknameEvaluator = {
+  async evaluate(
+    transcript: { id: string; text: string }[],
+  ): Promise<NicknameProposal[]> {
+    const out: NicknameProposal[] = [];
+    for (const entry of transcript) {
+      for (const pattern of PATTERNS) {
+        const m = pattern.regex.exec(entry.text);
+        if (m === null) continue;
+        const captured = m[1];
+        if (captured === undefined) continue;
+        const nickname = trimNickname(captured);
+        if (nickname.length === 0) continue;
+        out.push({
+          nickname,
+          subject: pattern.subject,
+          confidence: pattern.confidence,
+          supportingTranscriptId: entry.id,
+        });
+      }
+    }
+    return out;
+  },
+};

packages/app-core/src/services/voice-profiles/owner-confidence.ts

@@ -0,0 +1,60 @@
+import type { OwnerConfidence } from "./types.ts";
+
+export interface OwnerConfidenceInput {
+  voiceSimilarityToOwnerProfile: number;
+  deviceTrustLevel: "low" | "medium" | "high";
+  recentlyAuthenticated: boolean;
+  contextExpectsOwner: boolean;
+  challengeRecentlyPassed: boolean;
+}
+
+const DEVICE_TRUST_WEIGHT: Record<"low" | "medium" | "high", number> = {
+  low: 0.0,
+  medium: 0.1,
+  high: 0.2,
+};
+
+const CHALLENGE_WEIGHT = 0.45;
+const RECENT_AUTH_WEIGHT = 0.35;
+const VOICE_WEIGHT_CAP = 0.25;
+const CONTEXT_WEIGHT = 0.1;
+
+export function scoreOwnerConfidence(
+  input: OwnerConfidenceInput,
+): OwnerConfidence {
+  const reasons: string[] = [];
+  let score = 0;
+
+  if (input.challengeRecentlyPassed) {
+    score += CHALLENGE_WEIGHT;
+    reasons.push("challenge-recently-passed");
+  }
+  if (input.recentlyAuthenticated) {
+    score += RECENT_AUTH_WEIGHT;
+    reasons.push("recently-authenticated");
+  }
+
+  const clampedVoice = Math.max(
+    0,
+    Math.min(1, input.voiceSimilarityToOwnerProfile),
+  );
+  if (clampedVoice > 0) {
+    const voiceContribution = clampedVoice * VOICE_WEIGHT_CAP;
+    score += voiceContribution;
+    reasons.push(`voice-similarity:${clampedVoice.toFixed(2)}`);
+  }
+
+  const trust = DEVICE_TRUST_WEIGHT[input.deviceTrustLevel];
+  if (trust > 0) {
+    score += trust;
+    reasons.push(`device-trust:${input.deviceTrustLevel}`);
+  }
+
+  if (input.contextExpectsOwner) {
+    score += CONTEXT_WEIGHT;
+    reasons.push("context-expects-owner");
+  }
+
+  const clamped = Math.max(0, Math.min(1, score));
+  return { score: clamped, reasons };
+}

packages/app-core/src/services/voice-profiles/private-challenge.ts

@@ -0,0 +1,61 @@
+import { createHash, randomUUID } from "node:crypto";
+import type { OwnerChallenge } from "./types.ts";
+
+export interface ChallengeService {
+  issue(seed?: string): Promise<OwnerChallenge>;
+  verify(id: string, answer: string): Promise<boolean>;
+}
+
+export interface InMemoryChallengeServiceOptions {
+  now?: () => number;
+  ttlMs?: number;
+  expectedAnswer?: string;
+}
+
+const DEFAULT_TTL_MS = 5 * 60_000;
+
+function sha256Hex(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export class InMemoryChallengeService implements ChallengeService {
+  private readonly now: () => number;
+  private readonly ttlMs: number;
+  private readonly expectedAnswer: string | null;
+  private readonly active = new Map<string, OwnerChallenge>();
+
+  constructor(options: InMemoryChallengeServiceOptions = {}) {
+    this.now = options.now ?? Date.now;
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this.expectedAnswer = options.expectedAnswer ?? null;
+  }
+
+  async issue(seed?: string): Promise<OwnerChallenge> {
+    const createdAt = this.now();
+    const id = randomUUID();
+    const prompt = seed ?? "Confirm your private phrase";
+    const answerSource =
+      this.expectedAnswer ?? `${id}:${seed ?? "default"}`;
+    const challenge: OwnerChallenge = {
+      id,
+      prompt,
+      expectedAnswerHash: sha256Hex(answerSource),
+      createdAt,
+      expiresAt: createdAt + this.ttlMs,
+    };
+    this.active.set(id, challenge);
+    return challenge;
+  }
+
+  async verify(id: string, answer: string): Promise<boolean> {
+    const challenge = this.active.get(id);
+    if (challenge === undefined) return false;
+    if (this.now() > challenge.expiresAt) {
+      this.active.delete(id);
+      return false;
+    }
+    const ok = sha256Hex(answer) === challenge.expectedAnswerHash;
+    if (ok) this.active.delete(id);
+    return ok;
+  }
+}

packages/os/linux/desktop-shell/src/bridge/__tests__/client.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it, vi } from "vitest";
+import type { AudioState, BatteryState, SystemTime, WifiState } from "../../types";
+import { LINUX_BRIDGE_CHANNELS } from "../bridge-contract";
+import { createLinuxBridgeClient } from "../client";
+import type { BridgeTransport } from "../transport";
+
+interface Recorder {
+  onCalls: Array<{ channel: string }>;
+  sendCalls: Array<{ channel: string; payload: unknown }>;
+  emit(channel: string, payload: unknown): void;
+}
+
+function makeTransport(): { transport: BridgeTransport; rec: Recorder } {
+  const handlers = new Map<string, Set<(payload: unknown) => void>>();
+  const rec: Recorder = {
+    onCalls: [],
+    sendCalls: [],
+    emit(channel, payload) {
+      const set = handlers.get(channel);
+      if (!set) return;
+      for (const h of set) h(payload);
+    },
+  };
+  const transport: BridgeTransport = {
+    on<T>(channel: string, handler: (payload: T) => void) {
+      rec.onCalls.push({ channel });
+      const cast = handler as (payload: unknown) => void;
+      let set = handlers.get(channel);
+      if (!set) {
+        set = new Set();
+        handlers.set(channel, set);
+      }
+      set.add(cast);
+      return () => {
+        set?.delete(cast);
+      };
+    },
+    send: vi.fn(async (channel: string, payload: unknown) => {
+      rec.sendCalls.push({ channel, payload });
+      return { ok: true } as never;
+    }),
+  };
+  return { transport, rec };
+}
+
+describe("createLinuxBridgeClient", () => {
+  it("subscribes to wifi/audio/battery/time state channels", () => {
+    const { transport, rec } = makeTransport();
+    const client = createLinuxBridgeClient(transport);
+
+    const wifi: WifiState[] = [];
+    const audio: AudioState[] = [];
+    const battery: BatteryState[] = [];
+    const time: SystemTime[] = [];
+
+    const offW = client.subscribeWifi((s) => wifi.push(s));
+    const offA = client.subscribeAudio((s) => audio.push(s));
+    const offB = client.subscribeBattery((s) => battery.push(s));
+    const offT = client.subscribeTime((s) => time.push(s));
+
+    expect(rec.onCalls.map((c) => c.channel)).toEqual([
+      LINUX_BRIDGE_CHANNELS.wifi.state,
+      LINUX_BRIDGE_CHANNELS.audio.state,
+      LINUX_BRIDGE_CHANNELS.battery.state,
+      LINUX_BRIDGE_CHANNELS.time.state,
+    ]);
+
+    rec.emit(LINUX_BRIDGE_CHANNELS.wifi.state, { connected: true, ssid: "x" });
+    rec.emit(LINUX_BRIDGE_CHANNELS.audio.state, { level: 0.3, muted: false });
+    rec.emit(LINUX_BRIDGE_CHANNELS.battery.state, { percent: 80, charging: true });
+    rec.emit(LINUX_BRIDGE_CHANNELS.time.state, {
+      now: 123,
+      locale: "en-US",
+      timeZone: "UTC",
+    });
+
+    expect(wifi).toHaveLength(1);
+    expect(audio).toHaveLength(1);
+    expect(battery).toHaveLength(1);
+    expect(time).toHaveLength(1);
+
+    offW();
+    offA();
+    offB();
+    offT();
+
+    rec.emit(LINUX_BRIDGE_CHANNELS.wifi.state, { connected: false });
+    expect(wifi).toHaveLength(1);
+  });
+
+  it("sends typed audio + power + settings commands", async () => {
+    const { transport, rec } = makeTransport();
+    const client = createLinuxBridgeClient(transport);
+
+    await client.setAudioLevel(0.42);
+    await client.setAudioMuted(true);
+    await client.shutdown();
+    await client.restart();
+    await client.suspend();
+    await client.openSettings();
+
+    expect(rec.sendCalls).toEqual([
+      { channel: LINUX_BRIDGE_CHANNELS.audio.setLevel, payload: { level: 0.42 } },
+      { channel: LINUX_BRIDGE_CHANNELS.audio.setMuted, payload: { muted: true } },
+      { channel: LINUX_BRIDGE_CHANNELS.power.shutdown, payload: {} },
+      { channel: LINUX_BRIDGE_CHANNELS.power.restart, payload: {} },
+      { channel: LINUX_BRIDGE_CHANNELS.power.suspend, payload: {} },
+      { channel: LINUX_BRIDGE_CHANNELS.settings.open, payload: {} },
+    ]);
+  });
+});