mixdog 1.3.0 → 1.3.1

package/src/runtime/attachments/store.mjs

@@ -166,6 +166,12 @@ function saveBuffer(buffer) {
   return { attachmentRef, sizeBytes: buffer.length };
 }
 
+/** Store `buffer` (a file a bot or agent hands on, session-runtime/
+ *  handoff-attachments.mjs) under its content address: `{ attachmentRef, sizeBytes }`. */
+export function storeAttachmentBuffer(buffer) {
+  return saveBuffer(buffer);
+}
+
 export function isAttachmentReference(value) {
   return Boolean(value && typeof value === 'object' && ATTACHMENT_REF_RE.test(String(value.attachmentRef || '')));
 }

package/src/runtime/effort-judge/judge-client.mjs

@@ -267,7 +267,7 @@ export function effortJudgeInfo(dir = effortJudgeModelDir()) {
     /* not installed */
   }
   // The installed model names its backbone in calibration.json; older packs predate the field.
-  let backbone = 'mmBERT-small';
+  let backbone = 'EmbeddingGemma 2 (18 layers)';
   try {
     backbone = JSON.parse(readFileSync(join(dir, 'calibration.json'), 'utf8')).backbone || backbone;
   } catch {

package/src/runtime/effort-judge/model-manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release": "effort-judge-v6",
+  "release": "effort-judge-v7",
   "files": {
     "model.onnx": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/effort-judge-v6/model.onnx",
-      "sha256": "5abed811aaa44690f8d6292472aa8d930abae49f73a99265bb7fe874044df395",
+      "url": "https://github.com/tribgames/mixdog/releases/download/effort-judge-v7/model.onnx",
+      "sha256": "d01ceb1685e123335d2b70809e7b53fcc07ffb110b9412b408bc6b09a5394288",
       "size": 153062716
     },
     "tokenizer.json": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/effort-judge-v6/tokenizer.json",
+      "url": "https://github.com/tribgames/mixdog/releases/download/effort-judge-v7/tokenizer.json",
       "sha256": "22c064aaa468855d6211fe5c2ec8fdec595c97c55eb2ffd3b9fdf71a93b16292",
       "size": 32170665
     },
     "calibration.json": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/effort-judge-v6/calibration.json",
-      "sha256": "cc52c28b19fa891cca8913c69871235d5f863bd224d9336ada7d0f8cfb0765f6",
-      "size": 157
+      "url": "https://github.com/tribgames/mixdog/releases/download/effort-judge-v7/calibration.json",
+      "sha256": "01fe4cc99972bcca15e6ce8384cabf83c5705117e33da9a87541dc0f3d60a035",
+      "size": 223
     }
   }
 }

package/src/runtime/shared/agent-kind.mjs

@@ -0,0 +1,152 @@
+// An agent definition's kind (isContactAgentId reads it), decided read-only —
+// the one rule for the runtime and the desktop (which reads `kind` from the
+// runtime's catalog rows). Nothing is ever stamped on disk.
+//
+// An explicit frontmatter `kind` wins (`bot` from the bot dialog and Mixy's
+// setup tool, `agent` from the Workflows page and other chats). v1.3.0 wrote
+// no marker for bots, and v1.2.6 agents have none either, so an unmarked
+// user-made agent is a bot only on evidence that only a v1.3.0 bot creation
+// produced:
+//   T1  its home thread holds the creation greeting (agentGreetingKickoff,
+//       sent only to bots a dialog or the host greeted on creation; agents
+//       older than 1.3 were recorded without one);
+//   T2  its agent.json has an `avatar` (the bot dialog always sent one) AND
+//       its AGENT.md body is the bot dialog's default (agentBodyFromBrief).
+// Anything else is a workflow agent, as in v1.2.6.
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentHomeSessionId } from '../agent/orchestrator/session/agent-home.mjs';
+import { readMarkdownDocument } from './markdown-frontmatter.mjs';
+import { BOT_AGENT_KIND } from './agent-route-config.mjs';
+import { botStoreActive, isStoreBot } from './agent-store.mjs';
+
+const RUNTIME_MARKER = '[mixdog-runtime]';
+/** The creation greeting's opening (shared/agent-greeting.ts, v1.3.0 on). */
+const CREATION_GREETING = /(^|\n)\[mixdog-runtime\] The user just created you as /;
+/** The closing lines of the bot dialog's default AGENT.md (agentBodyFromBrief). */
+const DIALOG_BODY_TAIL = [
+  /^- Help the user( with this role)? in a natural, friendly conversation, in the language they write in\.$/,
+  /^- Ask a short question when a request is unclear, and say plainly when something is outside what you do\.$/,
+  /^- Keep replies as short or as detailed as the moment needs\.$/,
+];
+
+function messageText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((part) => (typeof part === 'string' ? part : typeof part?.text === 'string' ? part.text : ''))
+    .join('\n');
+}
+
+const NO_HOME = Object.freeze({ exists: false, greeted: false, chatted: false });
+// Per session file, keyed by its size and mtime: a home thread is read once
+// until it changes.
+const homeEvidenceCache = new Map();
+
+/** What `agentId`'s home thread (sessions/sess_home_<id>.json) holds:
+ *  whether it exists, whether it has the creation greeting, and whether the
+ *  user and the agent talked (any user message that is not a runtime turn,
+ *  or any assistant message). A missing or unreadable file holds nothing. */
+export function homeThreadEvidence(dataDir, agentId) {
+  const sessionId = agentHomeSessionId(agentId);
+  if (!dataDir || !sessionId) return NO_HOME;
+  const file = join(dataDir, 'sessions', `${sessionId}.json`);
+  let stat;
+  try {
+    stat = statSync(file);
+  } catch {
+    return NO_HOME;
+  }
+  const cached = homeEvidenceCache.get(file);
+  if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.value;
+  let messages = [];
+  try {
+    const doc = JSON.parse(readFileSync(file, 'utf8'));
+    if (Array.isArray(doc?.messages)) messages = doc.messages;
+  } catch {
+    // unreadable: it proves nothing
+  }
+  let greeted = false;
+  let chatted = false;
+  for (const message of messages) {
+    if (message?.role === 'assistant') chatted = true;
+    if (message?.role !== 'user') continue;
+    const text = messageText(message.content);
+    if (CREATION_GREETING.test(text)) greeted = true;
+    else if (text.trim() && !text.trimStart().startsWith(RUNTIME_MARKER)) chatted = true;
+  }
+  const value = Object.freeze({ exists: true, greeted, chatted });
+  homeEvidenceCache.set(file, { size: stat.size, mtimeMs: stat.mtimeMs, value });
+  return value;
+}
+
+function isDialogDefaultBody(body) {
+  const lines = String(body || '')
+    .trim()
+    .split(/\r?\n/);
+  const tail = lines.slice(-DIALOG_BODY_TAIL.length);
+  return tail.length === DIALOG_BODY_TAIL.length && DIALOG_BODY_TAIL.every((line, index) => line.test(tail[index]));
+}
+
+/** The definition's kind: the explicit frontmatter kind (lower-cased); else,
+ *  for an unmarked user-made agent (`dataDir`/`id` given, not a shipped role),
+ *  `bot` on T1 or T2 evidence; else null (a workflow agent). `manifest` and
+ *  `body` are the user copy's agent.json and AGENT.md body. */
+export function agentDefinitionKind(definition) {
+  const { dataDir, id } = definition;
+  // Once bots have their own store the folder decides: bots/ holds bots,
+  // agents/ workflow agents (an explicit marker still read as written).
+  if (dataDir && id && isStoreBot(dataDir, id)) return BOT_AGENT_KIND;
+  if (dataDir && botStoreActive(dataDir)) return explicitKind(definition.frontmatterKind);
+  return evidenceKind(definition);
+}
+
+const explicitKind = (frontmatterKind) =>
+  (typeof frontmatterKind === 'string' ? frontmatterKind.trim().toLowerCase() : '') || null;
+
+/** The pre-store rule alone (the split's decision input): the explicit kind,
+ *  else `bot` on T1/T2 evidence for an unmarked user-made agent, else null. */
+export function evidenceKind({ frontmatterKind, dataDir, shippedRoot, id, manifest, body }) {
+  const explicit = explicitKind(frontmatterKind);
+  if (explicit) return explicit;
+  if (!dataDir || !id || id === 'lead') return null;
+  if (shippedRoot && existsSync(join(shippedRoot, 'agents', id, 'AGENT.md'))) return null;
+  if (manifest?.avatar && isDialogDefaultBody(body)) return BOT_AGENT_KIND;
+  return homeThreadEvidence(dataDir, id).greeted ? BOT_AGENT_KIND : null;
+}
+
+/** agentDefinitionKind from the user copy on disk, for readers that have no
+ *  loaded definition at hand: a store bot (bots/<id>/) is a bot; any other id
+ *  is read from agents/<id>/, else from the shipped role. */
+export function readAgentDefinitionKind({ dataDir, shippedRoot, id }) {
+  if (isStoreBot(dataDir, id)) return BOT_AGENT_KIND;
+  const dir = join(dataDir, 'agents', id);
+  let doc;
+  try {
+    doc = readMarkdownDocument(readFileSync(join(dir, 'AGENT.md'), 'utf8'));
+  } catch {
+    // No user copy: the shipped role's own frontmatter decides.
+    try {
+      return agentDefinitionKind({
+        frontmatterKind: readMarkdownDocument(readFileSync(join(shippedRoot, 'agents', id, 'AGENT.md'), 'utf8'))
+          .frontmatter.kind,
+      });
+    } catch {
+      return null;
+    }
+  }
+  let manifest = {};
+  try {
+    manifest = JSON.parse(readFileSync(join(dir, 'agent.json'), 'utf8')) || {};
+  } catch {
+    manifest = {};
+  }
+  return agentDefinitionKind({
+    frontmatterKind: doc.frontmatter.kind,
+    dataDir,
+    shippedRoot,
+    id,
+    manifest,
+    body: doc.body,
+  });
+}

package/src/runtime/shared/agent-route-config.d.mts

@@ -1,3 +1,4 @@
 // Types for the desktop's one import of agent-route-config.mjs.
 export const WORKFLOW_AGENT_KIND: 'agent';
+export const BOT_AGENT_KIND: 'bot';
 export function isContactAgentId(value: unknown, kind?: unknown): boolean;

package/src/runtime/shared/agent-route-config.mjs

@@ -20,16 +20,20 @@ export const DEFAULT_DISABLED_AGENT_ROSTER = Object.freeze([...DEFAULT_DISABLED_
  *  an agent: a workflow delegation role, never a contact (봇). */
 export const WORKFLOW_AGENT_KIND = 'agent';
 
-/** A contact agent (a 봇): one the user made — not Mixy ('lead'), not a
- *  shipped role (the starter sub-agents Worker, Reviewer, … and the
- *  Maintainer), and not marked `kind: agent` (made on the Workflows page).
- *  `kind` is the definition's frontmatter `kind`; an unmarked custom agent
- *  stays a contact. The one rule for the runtime (delegation, agent catalogs)
- *  and the desktop (contacts, agent lists). */
+/** The AGENT.md frontmatter `kind` every bot creation path writes: the bot
+ *  dialog, and the setup tool when Mixy (agent mode) creates an agent. */
+export const BOT_AGENT_KIND = 'bot';
+
+/** A contact agent (a 봇): one explicitly marked `kind: bot` at creation —
+ *  never Mixy ('lead') nor a shipped role (the starter sub-agents Worker,
+ *  Reviewer, … and the Maintainer). `kind` is the definition's frontmatter
+ *  `kind`; an unmarked custom agent (every agent made before bots existed)
+ *  stays a workflow agent. The one rule for the runtime (delegation, agent
+ *  catalogs) and the desktop (contacts, agent lists). */
 export function isContactAgentId(value, kind) {
   const id = typeof value === 'string' ? value.trim().toLowerCase() : '';
-  const marked = typeof kind === 'string' && kind.trim().toLowerCase() === WORKFLOW_AGENT_KIND;
-  return Boolean(id) && id !== 'lead' && !DEFAULT_DISABLED_AGENT_ROSTER.includes(id) && !marked;
+  const bot = typeof kind === 'string' && kind.trim().toLowerCase() === BOT_AGENT_KIND;
+  return Boolean(id) && id !== 'lead' && !DEFAULT_DISABLED_AGENT_ROSTER.includes(id) && bot;
 }
 
 function record(value) {
@@ -128,9 +132,19 @@ export function withAgentDisabled(config, agentId, disabled) {
 // left under retired slots (agents.maintenance, workflowRoutes.*,
 // maintenance.memory, generated workflow-* presets) are scrubbed by
 // canonicalizeAgentRouteStorage, never folded in.
+// A bot's route lives with the bot (agent-store.mjs registers the reader in
+// the runtime): the resolver answers a route, null (a bot without one), or
+// undefined (no bot — the config decides).
+let botRouteResolver = null;
+export function setBotRouteResolver(resolver) {
+  botRouteResolver = typeof resolver === 'function' ? resolver : null;
+}
+
 export function configuredAgentRouteCandidates(config, agentId) {
   const id = String(agentId || '').trim();
   if (!id) return [];
+  const bot = botRouteResolver?.(id);
+  if (bot !== undefined) return bot ? [bot] : [];
   const route = record(config?.agents)[id];
   return route ? [route] : [];
 }

package/src/runtime/shared/agent-store.mjs

@@ -0,0 +1,132 @@
+// Where a user-made definition lives once bots have their own store (1.3.1):
+// bots under <dataDir>/bots/<id>/ (with their own model route in agent.json),
+// workflow agents under <dataDir>/agents/<id>/. The store is active once the
+// one-time split finished (bots/migration.json, bot-split-migration.mjs);
+// before that — or if it never could run — every reader sees agents/ as
+// before. The ids the split copied are bots for good: their agents/ originals
+// stay on disk for rollback but no catalog reads them again.
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { setBotRouteResolver } from './agent-route-config.mjs';
+
+export const BOTS_DIR = 'bots';
+export const BOT_MIGRATION_MANIFEST = 'migration.json';
+export const BOT_MIGRATION_VERSION = 1;
+/** Mixy's bot id once it has its own folder. */
+export const MIXY_BOT_ID = 'mixy';
+
+function readJson(file) {
+  try {
+    const value = JSON.parse(readFileSync(file, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+// Small stat-keyed caches: the store is read on route and catalog paths.
+const fileCache = new Map();
+function cachedJson(file) {
+  let stat;
+  try {
+    stat = statSync(file);
+  } catch {
+    fileCache.delete(file);
+    return null;
+  }
+  const hit = fileCache.get(file);
+  if (hit && hit.mtimeMs === stat.mtimeMs && hit.size === stat.size) return hit.value;
+  const value = readJson(file);
+  fileCache.set(file, { mtimeMs: stat.mtimeMs, size: stat.size, value });
+  return value;
+}
+
+/** The finished split's record, or null before it ran. */
+export function readBotMigration(dataDir) {
+  if (!dataDir) return null;
+  const manifest = cachedJson(join(dataDir, BOTS_DIR, BOT_MIGRATION_MANIFEST));
+  return manifest?.version === BOT_MIGRATION_VERSION ? manifest : null;
+}
+
+/** Whether `dataDir` has its bot store (the split finished). */
+export function botStoreActive(dataDir) {
+  return readBotMigration(dataDir) !== null;
+}
+
+/** The agents/ ids the split copied to bots/: the agent catalog skips them. */
+export function migratedBotIds(dataDir) {
+  return new Set(readBotMigration(dataDir)?.bots || []);
+}
+
+export const botDir = (dataDir, id) => join(dataDir, BOTS_DIR, id);
+
+/** Whether `id` is a store bot: the store is active and the bot has its
+ *  folder, or the split copied it (an id it moved is never an agent again).
+ *  Mixy's own folder is no ordinary bot. */
+export function isStoreBot(dataDir, id) {
+  if (!dataDir || !id || id === MIXY_BOT_ID || id.startsWith('.')) return false;
+  const manifest = readBotMigration(dataDir);
+  if (!manifest) return false;
+  return existsSync(botDir(dataDir, id)) || (manifest.bots || []).includes(id);
+}
+
+/** The folder of a user-made definition: bots/<id> for a store bot, else agents/<id>. */
+export function userDefinitionDir(dataDir, id) {
+  return isStoreBot(dataDir, id) ? botDir(dataDir, id) : join(dataDir, 'agents', id);
+}
+
+const isCompleteRoute = (route) =>
+  Boolean(
+    route && typeof route === 'object' && String(route.provider || '').trim() && String(route.model || '').trim()
+  );
+
+/** A store bot's own route (agent.json `route`): the route, null when it has
+ *  none, undefined when `id` is no store bot. */
+export function readBotRoute(dataDir, id) {
+  if (!isStoreBot(dataDir, id)) return undefined;
+  const route = cachedJson(join(botDir(dataDir, id), 'agent.json'))?.route;
+  return isCompleteRoute(route) ? route : null;
+}
+
+/** Stores (or with null removes) a store bot's route in its agent.json; every
+ *  other key is kept. */
+export function writeBotRoute(dataDir, id, route) {
+  const dir = botDir(dataDir, id);
+  const file = join(dir, 'agent.json');
+  const manifest = readJson(file) || {};
+  if (route) manifest.route = route;
+  else delete manifest.route;
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
+  fileCache.delete(file);
+}
+
+// --- Mixy: its own bot (bots/mixy), apart from the Lead ---
+// Mixy's identity (name, face, persona, 일하는 방식, connectors, `created`)
+// lives in bots/mixy once the store is active, in agents/lead before. Its
+// model route is always its own (bots/mixy/agent.json `route`), never the
+// Lead's: changing one never changes the other. Its home thread keeps the id
+// sess_home_lead, and its runtime role id stays `lead`.
+
+/** The folder Mixy's identity is read from and written to. */
+export function mixyIdentityDir(dataDir) {
+  return botStoreActive(dataDir) ? botDir(dataDir, MIXY_BOT_ID) : join(dataDir, 'agents', 'lead');
+}
+
+/** Mixy's own route, or null when it has none (its thread keeps its own). */
+export function readMixyRoute(dataDir) {
+  if (!dataDir) return null;
+  const route = cachedJson(join(botDir(dataDir, MIXY_BOT_ID), 'agent.json'))?.route;
+  return isCompleteRoute(route) ? route : null;
+}
+
+/** Stores (or with null removes) Mixy's own route; nothing of the Lead's. */
+export function writeMixyRoute(dataDir, route) {
+  writeBotRoute(dataDir, MIXY_BOT_ID, route);
+}
+
+/** Every config route read (configuredAgentRouteCandidates) asks the bot
+ *  store first: a bot's route lives with the bot, never in the config. */
+export function registerBotRouteStore(getDataDir) {
+  setBotRouteResolver((id) => readBotRoute(getDataDir(), id));
+}