mixdog 1.3.4 → 1.4.0

package/src/runtime/shared/file-permissions.mjs

@@ -267,17 +267,6 @@ export async function prewarmOwnerOnlyAclWin32({ bridge = true } = {}) {
   }
 }
 
-/** Test/diagnostic hook: whether a helper is attached, its requests awaiting
- *  an answer, and the starts inside the current restart window. */
-export function ownerOnlyAclHelperStats() {
-  return {
-    alive: aclHelper !== null,
-    pid: aclHelper?.child.pid ?? null,
-    pending: aclHelper?.pending.size ?? 0,
-    recentStarts: aclHelperStartTimes.length,
-  };
-}
-
 /** Test hook: the live helper process, or null. */
 export function ownerOnlyAclHelperForTests() {
   return aclHelper?.child ?? null;

package/src/runtime/shared/git-direct.test-support.mjs

@@ -0,0 +1,19 @@
+// Side-effect import for the git-heavy suites. Import it before anything that
+// spawns git or snapshots process.env.
+//
+// On Windows `git` on PATH is usually Git for Windows' cmd\git.exe launcher,
+// which starts the real git.exe as a second process, so every spawn pays two
+// process creations (~75 ms instead of ~40 ms). These suites spawn hundreds of
+// git processes, test and code under test alike (the git runner worker shares
+// process.env), so the real binary's directory (`git --exec-path`, where git
+// itself resolves its subcommands) goes first on PATH. Same git, same config;
+// only the launcher hop is skipped. Elsewhere `git` already is the binary.
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { delimiter, join, normalize } from 'node:path';
+
+if (process.platform === 'win32') {
+  const probe = spawnSync('git', ['--exec-path'], { encoding: 'utf8', windowsHide: true });
+  const dir = probe.status === 0 ? normalize(probe.stdout.trim()) : '';
+  if (dir && existsSync(join(dir, 'git.exe'))) process.env.PATH = `${dir}${delimiter}${process.env.PATH}`;
+}

package/src/runtime/shared/google-oauth-client.generated.json

@@ -0,0 +1,4 @@
+{
+  "clientId": "187841207053-o7jhqbnjjh99kfio1fgs7422m540q75m.apps.googleusercontent.com",
+  "clientSecret": "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"
+}

package/src/runtime/shared/google-oauth-client.mjs

@@ -6,18 +6,43 @@
 // uses PKCE (S256), state and a loopback redirect
 // (developers.google.com/identity/protocols/oauth2/native-app).
 //
-// The values come only from the environment; the source ships none, so a
-// build without them offers no built-in Google sign-in (the user's own
-// Google client still works).
+// The source ships no client. The values come from the environment first
+// (MIXDOG_GOOGLE_OAUTH_CLIENT_ID / _SECRET: a developer's override, and what
+// `npm run dev:isolated` passes through), then from the generated, gitignored
+// google-oauth-client.generated.json beside this file. Release packaging
+// writes that file from the repository secrets
+// (scripts/embed-google-oauth-client.mjs) before the npm package and every
+// desktop runtime.asar are built, so each shipped build carries it. A build
+// with neither offers no built-in Google sign-in (the user's own Google
+// client still works).
 
-const value = (name) => String(process.env[name] || '').trim();
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+/** The generated file release packaging writes (see the header). */
+export const GOOGLE_OAUTH_CLIENT_FILE = fileURLToPath(new URL('./google-oauth-client.generated.json', import.meta.url));
+
+const text = (value) => String(value || '').trim();
+
+function embeddedClient(file) {
+  let source;
+  try {
+    source = readFileSync(file, 'utf8');
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+  const { clientId, clientSecret } = JSON.parse(source);
+  return text(clientId) ? { clientId: text(clientId), clientSecret: text(clientSecret) } : null;
+}
 
 /** `{ clientId, clientSecret }` of Mixdog's Google client, or null when this
- *  build has none. */
-export function googleOAuthClient() {
-  const clientId = value('MIXDOG_GOOGLE_OAUTH_CLIENT_ID');
-  if (!clientId) return null;
-  return { clientId, clientSecret: value('MIXDOG_GOOGLE_OAUTH_CLIENT_SECRET') };
+ *  build has none. The environment wins over the generated file as a whole:
+ *  the two are never mixed. */
+export function googleOAuthClient({ env = process.env, file = GOOGLE_OAUTH_CLIENT_FILE } = {}) {
+  const clientId = text(env.MIXDOG_GOOGLE_OAUTH_CLIENT_ID);
+  if (clientId) return { clientId, clientSecret: text(env.MIXDOG_GOOGLE_OAUTH_CLIENT_SECRET) };
+  return embeddedClient(file);
 }
 
 /** Google issues a refresh token only for `access_type=offline`. */

package/src/runtime/shared/heartbeat-interval.d.mts

@@ -0,0 +1,4 @@
+export const HEARTBEAT_INTERVAL_CHOICES: readonly number[];
+export const DEFAULT_HEARTBEAT_INTERVAL_MINUTES: number;
+export function normalizeHeartbeatIntervalMinutes(value: unknown): number;
+export function requireHeartbeatIntervalMinutes(value: unknown): number;

package/src/runtime/shared/heartbeat-interval.mjs

@@ -0,0 +1,19 @@
+// Mixy's heartbeat interval setting (`heartbeatIntervalMinutes` in the config):
+// one of a few fixed choices, shared by the runtime, the desktop's IPC check
+// and the Settings picker. "Off" is the separate `heartbeat` switch.
+export const HEARTBEAT_INTERVAL_CHOICES = Object.freeze([30, 60, 120, 240]);
+export const DEFAULT_HEARTBEAT_INTERVAL_MINUTES = 60;
+
+/** `value` when it is one of the choices, else the default (a stored value
+ *  that is no longer, or never was, a choice reads as the default). */
+export function normalizeHeartbeatIntervalMinutes(value) {
+  return HEARTBEAT_INTERVAL_CHOICES.includes(value) ? value : DEFAULT_HEARTBEAT_INTERVAL_MINUTES;
+}
+
+/** `value` when it is one of the choices; throws otherwise (a write). */
+export function requireHeartbeatIntervalMinutes(value) {
+  if (!HEARTBEAT_INTERVAL_CHOICES.includes(value)) {
+    throw new Error(`heartbeat interval must be one of ${HEARTBEAT_INTERVAL_CHOICES.join(', ')} minutes`);
+  }
+  return value;
+}

package/src/runtime/shared/idle-auto-clear-gate.mjs

@@ -0,0 +1,104 @@
+// idle-auto-clear-gate.mjs — the idle auto-clear predicate, shared by the
+// submit gate (tui/session/session-flow/auto-clear.mjs); the cache warmer
+// (agent/orchestrator/session/cache-warm.mjs) registers its successful warms,
+// which count as cache use (sessionActivityTimestamp). A thread is cleared before
+// a submit when auto-clear is on, it has been idle for at least the window
+// since its activity timestamp, and its context is not below the minimum
+// share of the compaction trigger.
+import { attachmentTextForPart, isAttachmentReference } from '../attachments/store.mjs';
+
+export function promptContentText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (part?.type === 'text') return isAttachmentReference(part) ? attachmentTextForPart(part) : part.text || '';
+        if (part?.type === 'image') return '[Image]';
+        if (part?.type === 'file') return '[File]';
+        return part?.text || '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  return String(content ?? '');
+}
+
+function timestampMs(value) {
+  if (value == null || value === '') return 0;
+  const n = Number(value);
+  if (Number.isFinite(n) && n > 0) return n;
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function hasModelVisibleConversation(session) {
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  return messages.some((message) => {
+    const role = message?.role;
+    if (role !== 'user' && role !== 'assistant' && role !== 'tool') return false;
+    const text = promptContentText(message.content).trim();
+    if (role === 'user' && text.startsWith('<system-reminder>')) return false;
+    if (role === 'assistant' && text === '.' && !Array.isArray(message.toolCalls)) return false;
+    return !!text || role === 'assistant' || role === 'tool';
+  });
+}
+
+// When a session's prompt cache was last used by a successful cache warm (a
+// read with no write), registered by the warmer (cache-warm.mjs, from its
+// durable touch store); 0 when none.
+let lastCacheWarmUse = () => 0;
+
+/** Register the source of a session's last successful cache-warm use
+ *  (`(sessionId) => epoch ms | 0`); null restores none. */
+export function setCacheWarmUseSource(source) {
+  lastCacheWarmUse = typeof source === 'function' ? source : () => 0;
+}
+
+/**
+ * When the session was last active (0: no model-visible conversation): the
+ * latest of its own activity and the last successful cache warm. Idleness is
+ * measured from the last time the cached prompt was actually used, and a warm
+ * that read the cache without writing used it; the session's own timestamps
+ * are never moved.
+ */
+export function sessionActivityTimestamp(session, fallback = 0) {
+  if (!hasModelVisibleConversation(session)) return 0;
+  const own = timestampMs(session?.lastUsedAt) || timestampMs(session?.updatedAt) || timestampMs(fallback);
+  return Math.max(own, timestampMs(lastCacheWarmUse(session?.id)));
+}
+
+// A zero is often an unavailable/stale meter field, not an authoritative
+// measurement. Do not let it mask the sibling live estimate.
+function contextUsageBelowThreshold(runtime, minContextPercent) {
+  if (!(minContextPercent > 0)) return false;
+  const status = runtime.contextStatus?.() || null;
+  const usedTokens = Math.max(
+    0,
+    Number(status?.usedTokens) || 0,
+    Number(status?.currentEstimatedTokens) || 0,
+    Number(status?.compaction?.currentEstimatedTokens) || 0
+  );
+  const triggerTokens = Number(
+    status?.compaction?.triggerTokens ||
+      status?.compaction?.autoCompactTokenLimit ||
+      runtime.session?.autoCompactTokenLimit ||
+      0
+  );
+  if (!Number.isFinite(usedTokens) || !Number.isFinite(triggerTokens) || !(usedTokens > 0 && triggerTokens > 0)) {
+    return true;
+  }
+  return (usedTokens / triggerTokens) * 100 < minContextPercent;
+}
+
+/**
+ * Whether the idle gate clears the thread before a submit at `at`: `cfg` is
+ * the auto-clear state (`enabled`, `idleMs`, `minContextPercent`), the
+ * activity is `activityAt` (sessionActivityTimestamp) and `runtime` answers
+ * `contextStatus()` for the thread. The submit gate adds its own transient
+ * conditions (busy, queued input, a clear already running).
+ */
+export function idleAutoClearDue({ cfg, activityAt, at, runtime }) {
+  if (!cfg?.enabled || !activityAt || at - activityAt < cfg.idleMs) return false;
+  return !contextUsageBelowThreshold(runtime, Number(cfg.minContextPercent ?? 10));
+}

package/src/runtime/shared/llm/anthropic-betas.mjs

@@ -7,6 +7,9 @@ const FAST_MODE_BETA_HEADER = 'fast-mode-2026-02-01';
 const TOOL_SEARCH_BETA_HEADER = 'advanced-tool-use-2025-11-20';
 const THINKING_DISPLAY_UPDATES_BETA_HEADER = 'thinking-display-updates-2026-08-18';
 export const SERVER_SIDE_FALLBACK_BETA_HEADER = 'server-side-fallback-2026-07-01';
+// Turn-scoped mid-conversation system messages (clear_at), sent only when the
+// request body carries one.
+export const TURN_SCOPED_SYSTEM_BETA_HEADER = 'mid-conversation-system-clear-at-2026-08-21';
 
 // Fast mode ships on Opus 5.5, Opus 5 and Opus 4.8 only. Opus 4.7 rejects
 // `speed: "fast"` and Opus 4.6 silently runs at standard speed.
@@ -28,6 +31,7 @@ export function buildAnthropicBetaHeaders({
   effort = false,
   serverFallback = false,
   thinkingDisplayUpdates = false,
+  turnScopedSystem = false,
 } = {}) {
   const headers = String(base || '')
     .split(',')
@@ -48,5 +52,8 @@ export function buildAnthropicBetaHeaders({
   if (thinkingDisplayUpdates && !headers.includes(THINKING_DISPLAY_UPDATES_BETA_HEADER)) {
     headers.push(THINKING_DISPLAY_UPDATES_BETA_HEADER);
   }
+  if (turnScopedSystem && !headers.includes(TURN_SCOPED_SYSTEM_BETA_HEADER)) {
+    headers.push(TURN_SCOPED_SYSTEM_BETA_HEADER);
+  }
   return headers.join(',');
 }

package/src/runtime/shared/llm/anthropic-thinking-contract.mjs

@@ -63,3 +63,15 @@ export function emitsAnthropicProgressUpdates(model) {
   const id = normalizeClaudeModelId(model);
   return /^claude-(?:opus-5-5|sonnet-5-5|fable-5-1|mythos-5-1|fable-5)(?:-\d{8})?$/.test(id);
 }
+
+// Models that accept turn-scoped mid-conversation system messages
+// ({role:'system', clear_at:'next_user_message'}, beta
+// mid-conversation-system-clear-at-2026-08-21). An id list for the same
+// reason as above: a wrong "yes" is a 400 on every request, a wrong "no" only
+// keeps the legacy tail-reminder layout — so unknown ids stay off.
+export function supportsAnthropicTurnScopedSystemMessages(model) {
+  const id = normalizeClaudeModelId(model);
+  return /^claude-(?:fable-5-1|mythos-5-1|fable-5|mythos-5|opus-5-5|opus-5|opus-4-8|sonnet-5-5|haiku-5-5)(?:-\d{8})?$/.test(
+    id
+  );
+}

package/src/runtime/shared/llm/provider-catalog-registry.mjs

@@ -92,6 +92,7 @@ const PROVIDER_CATALOGS = Object.freeze({
     rosterLimitsAuthoritative: true,
   },
   'cursor-oauth': { relay: true },
+  'devin-oauth': { relay: true },
   'cursor-api': { relay: true },
   // The models.dev listing id of the Go gateway: a relay catalog, not a
   // selectable provider (the model lookup needs it flagged as a relay).

package/src/runtime/shared/llm/usage-rollup.mjs

@@ -22,7 +22,7 @@ export function usageRollupDayKey(ts) {
 // background runners. An unknown source counts as conversation on purpose: a
 // new runner showing up in the user's totals is visible and correctable, while
 // silently dropping the user's own turns is neither.
-const BACKGROUND_SOURCES = new Set(['memory-cycle', 'schedule', 'webhook', 'native-web-search']);
+const BACKGROUND_SOURCES = new Set(['memory-cycle', 'schedule', 'webhook', 'native-web-search', 'cache-warm']);
 
 export function isConversationUsageSource(sourceType) {
   const id = typeof sourceType === 'string' ? sourceType.trim().toLowerCase() : '';

package/src/runtime/shared/llm/well-formed.mjs

@@ -0,0 +1,66 @@
+/**
+ * Outgoing-request surrogate sanitizer.
+ *
+ * A lone UTF-16 surrogate (half of an emoji left by a char-count cut, or
+ * carried by tool output / file content) is serialized by JSON.stringify as a
+ * `\ud83d` escape that provider APIs reject ("not valid JSON"). This rewrites
+ * every string value and every object key to well-formed text (lone surrogate
+ * -> U+FFFD) in the request that is about to be sent.
+ *
+ * Copy-on-write: a request that is already well-formed is returned as the very
+ * same object (no allocation, identity kept for caches keyed on messages or
+ * tool lists). Only the containers on the path to a bad string are copied; the
+ * stored transcript is never mutated. Only arrays and plain objects are
+ * walked: Buffer / Uint8Array / ArrayBuffer and any other class instance are
+ * binary or opaque payloads and are returned untouched. Own symbol properties
+ * (e.g. the provider-native tool prefix count on a tool list) survive a copy.
+ */
+function copySymbols(target, source) {
+  for (const symbol of Object.getOwnPropertySymbols(source)) {
+    Object.defineProperty(target, symbol, Object.getOwnPropertyDescriptor(source, symbol));
+  }
+  return target;
+}
+
+function setOwn(target, key, value) {
+  Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+}
+
+function walk(value, active) {
+  if (typeof value === 'string') return value.isWellFormed() ? value : value.toWellFormed();
+  if (value === null || typeof value !== 'object' || active.has(value)) return value;
+  if (Array.isArray(value)) {
+    active.add(value);
+    let out = null;
+    for (let i = 0; i < value.length; i += 1) {
+      const next = walk(value[i], active);
+      if (!out && next !== value[i]) out = value.slice();
+      if (out) out[i] = next;
+    }
+    active.delete(value);
+    return out ? copySymbols(out, value) : value;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return value;
+  active.add(value);
+  const keys = Object.keys(value);
+  let out = null;
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    const entry = value[key];
+    const nextKey = key.isWellFormed() ? key : key.toWellFormed();
+    const nextEntry = walk(entry, active);
+    if (!out && (nextKey !== key || nextEntry !== entry)) {
+      out = Object.create(proto);
+      for (let j = 0; j < i; j += 1) setOwn(out, keys[j], value[keys[j]]);
+    }
+    if (out) setOwn(out, nextKey, nextEntry);
+  }
+  active.delete(value);
+  return out ? copySymbols(out, value) : value;
+}
+
+/** `value` with every string and object key made well-formed; `value` itself when it already is. */
+export function sanitizeSurrogates(value) {
+  return walk(value, new WeakSet());
+}

package/src/runtime/shared/mixy-presence.mjs

@@ -0,0 +1,22 @@
+// Whether the representative bot (Mixy) exists: the one rule. The desktop
+// answers from it (getLeadStatus `exists`, main/mixy-first.ts), and so do
+// Mixy's routines (routine-owner.mjs `no-mixy`), her heartbeat and the
+// heartbeat reports queued for her chat (mixy-heartbeat.mjs,
+// agent-home-delivery.mjs), all through routine-owner.mjs readMixyExists.
+//
+// `created: false` (Mixy's agent.json) is no. Otherwise she exists on
+// evidence that the user made or uses her:
+//   - a name (the 대표 에이전트 dialog always sets one; her profile can);
+//   - a message the user wrote in her thread (`homeChatted`,
+//     agent-kind.mjs homeThreadEvidence);
+//   - a schedule or webhook she owns (`ownsRoutines`): the user set it up,
+//     and since v1.3.0 it ran for her whether or not she was named.
+// Without any of them she does not exist: v1.3.0's untouched automatic
+// `{"created": true}`, and an undecided profile (`created` null). Her own
+// posts in her thread, heartbeat reports and routine results, are no
+// evidence. `ownsRoutines` is read only when nothing else decides.
+export async function mixyExists(status, ownsRoutines) {
+  if (status?.created === false) return false;
+  if (String(status?.name ?? '').trim() || status?.homeChatted === true) return true;
+  return (await ownsRoutines()) === true;
+}

package/src/runtime/shared/orchestration.d.mts

@@ -0,0 +1,2 @@
+export type OrchestrationMode = 'none' | 'focused' | 'balanced' | 'swarm';
+export function configuredOrchestrationMode(config: unknown): OrchestrationMode;

package/src/runtime/shared/pg-schema-db.mjs

@@ -1,21 +1,32 @@
-/** Lazy per-dataDir PG handle: one in-flight init, bootstrap lock, retry after failure. */
+import { createSharedAbortable } from './abort-race.mjs';
+
+/** Lazy per-dataDir PG handle: one in-flight init, bootstrap lock, retry after
+ *  failure. `signal` withdraws a caller; the init (a PG runtime install
+ *  included) is cancelled once every caller has (createSharedAbortable). */
 export function createPgSchemaDb({ schema, ddl, defaultDataDir, ensurePg, withLock }) {
   const ready = new Map();
-  return async function getDb(dataDir = defaultDataDir()) {
-    if (ready.has(dataDir)) return ready.get(dataDir);
-    const p = (async () => {
-      const { db, pool } = await ensurePg(dataDir, { schema });
-      // Serialize CREATE TABLE across concurrent first-boot processes on the
-      // same cluster-global advisory lock the adapter uses for schema bootstrap.
-      await withLock(pool, () => db.exec(ddl));
-      return db;
-    })();
-    ready.set(dataDir, p);
-    try {
-      return await p;
-    } catch (err) {
-      ready.delete(dataDir); // let the next call retry after a transient failure
-      throw err;
+  return function getDb(dataDir = defaultDataDir(), { signal = null } = {}) {
+    let shared = ready.get(dataDir);
+    if (!shared) {
+      const entry = createSharedAbortable(
+        async (initSignal) => {
+          const { db, pool } = await ensurePg(dataDir, { schema, signal: initSignal });
+          initSignal.throwIfAborted();
+          // Serialize CREATE TABLE across concurrent first-boot processes on the
+          // same cluster-global advisory lock the adapter uses for schema bootstrap.
+          await withLock(pool, () => db.exec(ddl));
+          return db;
+        },
+        {
+          // Let the next call retry after a transient failure or a cancellation.
+          onSettled: (failed) => {
+            if (failed && ready.get(dataDir) === entry) ready.delete(dataDir);
+          },
+        }
+      );
+      shared = entry;
+      ready.set(dataDir, entry);
     }
+    return shared.join(signal);
   };
 }

package/src/runtime/shared/profile-config.cjs

@@ -5,7 +5,7 @@
 const PROFILE_LANGUAGES = Object.freeze([
   { id: 'system', label: 'System (locale)', prompt: null },
   { id: 'en', label: 'English', prompt: 'English' },
-  { id: 'ko', label: 'Korean', prompt: 'Korean' },
+  { id: 'ko', label: '한국어', prompt: 'Korean' },
   { id: 'ja', label: '日本語', prompt: 'Japanese (日本語)' },
   { id: 'zh-Hans', label: '中文（简体）', prompt: 'Simplified Chinese (简体中文)' },
   { id: 'zh-Hant', label: '中文（繁體）', prompt: 'Traditional Chinese (繁體中文)' },

package/src/runtime/shared/prompt-origin.d.mts

@@ -0,0 +1,4 @@
+export declare const PROMPT_ORIGIN_CHANNEL: 'channel';
+export declare const PROMPT_ORIGIN_AGENT_REPORT: 'agent-report';
+export type PromptOrigin = typeof PROMPT_ORIGIN_CHANNEL | typeof PROMPT_ORIGIN_AGENT_REPORT;
+export declare function promptOriginOf(value: unknown): PromptOrigin | null;

package/src/runtime/shared/prompt-origin.mjs

@@ -0,0 +1,21 @@
+// A submitted prompt's provenance, carried apart from its presentation mode
+// (`origin` on the submit options, the queue entry, the turn input and the
+// stored user message's meta). Dependency-free: the desktop main process
+// stamps it too (agent-room-turn.ts).
+
+/** Real external activity presented as a task notification: an inbound
+ *  channel message (Discord, Telegram, webhook event rules …). */
+export const PROMPT_ORIGIN_CHANNEL = 'channel';
+
+/** A turn the runtime starts because another bot or agent reported back: a
+ *  bot-home wake (daemon.mjs `wake`) or a group-room member's relay of its
+ *  reported work (agent-room-turn.ts). System-caused, though presented as a
+ *  prompt. */
+export const PROMPT_ORIGIN_AGENT_REPORT = 'agent-report';
+
+const KNOWN_ORIGINS = new Set([PROMPT_ORIGIN_CHANNEL, PROMPT_ORIGIN_AGENT_REPORT]);
+
+/** `value` when it is a known provenance, else null. */
+export function promptOriginOf(value) {
+  return KNOWN_ORIGINS.has(value) ? value : null;
+}