mixdog 1.3.4 → 1.3.5

package/src/session-runtime/setup-tool/settings-contract.mjs

@@ -38,7 +38,7 @@ export const SETUP_EXTENDED_ACTION_FIELDS = Object.freeze({
   add_hook_rule: 'hookRule',
   set_hook_rule_enabled: 'ruleIndex enabled',
   delete_hook_rule: 'ruleIndex',
-  set_media_default: 'kind lane model?',
+  set_media_default: 'kind lane model? accountId?',
 });
 
 /** Mirrors RULE_ACTIONS in services/hook-bus/rule-store.mjs. */
@@ -177,6 +177,10 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
   entry: object(
     {
       name: text,
+      newName: {
+        ...text,
+        description: 'Schedule only, with overwrite: rename the schedule `name` to this; its history is kept.',
+      },
       description: text,
       instructions: text,
       time: { ...text, description: 'Schedule cron expression. Mutually exclusive with at.' },
@@ -234,6 +238,30 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
       maximum: 400,
       description: 'Windows only: notification sound volume percent.',
     },
+    botOverlay: object(
+      {
+        enabled: {
+          ...boolean,
+          description: 'Show the representative bot overlay; refused while no representative bot exists.',
+        },
+        position: {
+          type: 'string',
+          enum: ['pinned', 'pinnedHere', 'free', 'onScreen'],
+          description:
+            'pinned = pin above the message box (default); pinnedHere = pin here; free = free in the app window; onScreen = free on screen.',
+        },
+        keepAbove: { ...boolean, description: 'Keep above other windows (default off).' },
+        collapsed: { ...boolean, description: 'Collapse the bubble so only the bot shows (default off).' },
+        autoAdvance: { ...boolean, description: 'Auto-advance long replies (default on).' },
+        autoClose: { ...boolean, description: 'Close replies automatically once read (default on).' },
+        scale: {
+          type: 'integer',
+          enum: [50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200],
+          description: 'Bot size in percent (default 100).',
+        },
+      },
+      []
+    ),
   }),
   appearance: object({
     theme: { type: 'string', enum: ['system', 'dark', 'white'] },
@@ -242,6 +270,34 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
       description: 'Desktop UI language id from status appearance; independent of profile language.',
     },
     sidePanels: { type: 'string', enum: ['close-left', 'close-right', 'close-both', 'keep-open'] },
+    sidePanelPosition: {
+      type: 'string',
+      enum: ['right', 'bottom', 'auto'],
+      description: 'Where the side dock sits on desktop: beside the chat, below it, or by window shape (default right).',
+    },
+    timeFormat: {
+      type: 'string',
+      enum: ['system', '12h', '24h'],
+      description: 'Clock style for every time of day shown (default system = the UI language own clock).',
+    },
+    uiScale: {
+      type: 'number',
+      minimum: 0.85,
+      maximum: 1.2,
+      description: 'UI size multiplier, 0.85-1.2 in steps of 0.05 (default 1).',
+    },
+    codeSize: {
+      type: 'integer',
+      minimum: 10,
+      maximum: 20,
+      description: 'Code text size in px, 10-20 (default 13).',
+    },
+    codeLigatures: { ...boolean, description: 'Join symbols such as => into one glyph in code (default on).' },
+    chatTextSize: {
+      type: 'string',
+      enum: ['small', 'default', 'large', 'extra-large'],
+      description: 'Conversation and composer text size (default default).',
+    },
     markdownDefaultView: { type: 'string', enum: ['preview', 'rich', 'source'] },
     linkPreview: boolean,
     toolActivityExpansion: { type: 'string', enum: ['collapsed', 'commands', 'all'] },
@@ -290,10 +346,15 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     minimum: 0,
     description: 'set_hook_rule_enabled/delete_hook_rule: rule index from status hooks.',
   },
-  lane: { ...nonBlank, description: 'set_media_default: lane id from the media catalog.' },
+  lane: {
+    ...text,
+    description:
+      'set_media_default: lane id from the media catalog to pin as the default generator for the kind; "" clears the pin (back to Auto).',
+  },
   model: {
     ...nonBlank,
-    description: 'set_media_default: model id offered by the lane for the kind; omitted = the lane default.',
+    description:
+      'set_media_default: model id offered by the lane for the kind; omitted = the lane default. set_model_preferences: model id of the provider.',
   },
   project: object({ path: text, alias: text }, ['path']),
   projectPath: { ...text, description: 'Exact registered Project root.' },
@@ -306,7 +367,7 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
   riskAccepted: {
     ...boolean,
     description:
-      "set_developer_option: the user's explicit acceptance of the option warning; required to enable an option that has one.",
+      "set_developer_option: the user's explicit acceptance of the option warning; required to enable an option that has one. Exception: allowAllActions (allow all actions except payments and permanent deletes) can only be turned on by the person in the desktop app; it is rejected regardless of riskAccepted, and remote enablement is rejected too.",
   },
 });
 

package/src/session-runtime/setup-tool/tool-defs.mjs

@@ -9,6 +9,7 @@ import { INSTRUCTION_FILES_MODES } from '../../runtime/shared/instruction-files-
 import { AUTO_EFFORT_BASES } from '../../runtime/agent/orchestrator/providers/auto-effort.mjs';
 import { WORKTREE_NEW_TASK_DEFAULTS } from '../../runtime/shared/worktrees/settings.mjs';
 import { CONNECTOR_IDS } from '../../runtime/shared/connector-catalog.mjs';
+import { COMPACTION_SUMMARY_MODES } from '../../runtime/agent/orchestrator/session/compact/summary-mode.mjs';
 
 /** Built-in `setup` tool: the model's handle on a Mixdog user's persisted
  *  configuration. The description is a contract only; how to use each action
@@ -99,6 +100,11 @@ export const SETUP_ACTION_FIELDS = Object.freeze({
   delete_local_model: 'confirmationToken',
   set_system_shell: 'command',
   set_auto_update: 'enabled',
+  set_ai_session_titles: 'enabled',
+  set_quota_auto_resume: 'enabled',
+  set_model_preferences: 'provider model hidden? favorite?',
+  set_heartbeat_enabled: 'enabled',
+  set_reactions_enabled: 'enabled',
   forget_provider_auth: 'name accountId?',
   set_provider_account: 'name providerAccount',
   add_mcp_server: 'server',
@@ -130,6 +136,7 @@ export const SETUP_BUILTIN_TOGGLE_FEATURES = Object.freeze([
   'computer',
   'voice',
   'visualize',
+  'media',
 ]);
 
 const ROUTE_SCHEMA = {
@@ -248,13 +255,33 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           properties: {
             mainBufferTokens: { type: 'integer', minimum: 0 },
             mainBufferPercent: { type: 'number', minimum: 0, maximum: 100 },
+            onModelChange: {
+              type: 'boolean',
+              description: 'Auto-compact a conversation on its current model before it switches to another one.',
+            },
+            summaryMode: {
+              type: 'string',
+              enum: [...COMPACTION_SUMMARY_MODES],
+              description:
+                'Which model writes compaction summaries: smart (default), maintainer (the Maintainer), self (the conversation model).',
+            },
           },
-          description: 'set_compaction: reserved Main context budget. Give tokens OR percent, not both.',
+          description:
+            'set_compaction: reserved Main context budget (give tokens OR percent, not both), onModelChange and summaryMode; read back with status compaction.',
         },
         enabled: {
           type: 'boolean',
           description:
-            'Boolean setters (set_*_enabled, set_compaction, set_auto_update, set_mcp_enabled, set_plugin_enabled).',
+            'Boolean setters (set_*_enabled, set_compaction, set_auto_update, set_ai_session_titles, set_quota_auto_resume, set_heartbeat_enabled, set_mcp_enabled, set_plugin_enabled).',
+        },
+        provider: { type: 'string', description: 'set_model_preferences: provider id.' },
+        hidden: {
+          type: 'boolean',
+          description: 'set_model_preferences: false lists the model in /model, true hides it; omitted = unchanged.',
+        },
+        favorite: {
+          type: 'boolean',
+          description: 'set_model_preferences: favorite star on or off; omitted = unchanged.',
         },
         instructionFiles: {
           type: 'string',
@@ -275,7 +302,7 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         accountId: {
           type: 'string',
           description:
-            'forget_provider_auth: OAuth account id from status providers with detail:true; required when the provider has several accounts.',
+            'forget_provider_auth: OAuth account id from status providers with detail:true; required when the provider has several accounts. set_media_default: optional account of the OAuth lane to pin; omitted = the lane provider\'s selected account.',
         },
         providerAccount: {
           type: 'object',

package/src/session-runtime/task-session-route.mjs

@@ -0,0 +1,99 @@
+/**
+ * task-session-route.mjs — the model and reasoning effort a bot asks of a
+ * task session (the session tool's `model` / `effort`), checked against the
+ * provider catalog the desktop model menu lists (listProviderModels rows:
+ * provider, id, display, effortOptions).
+ */
+import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { normalizeEffortInput } from '../runtime/agent/orchestrator/runtime-core/effort.mjs';
+
+// Choices an error names: a short list, never the whole catalog.
+const CHOICE_LIMIT = 6;
+
+const lower = (value) => clean(value).toLowerCase();
+const rowId = (row) => clean(row.id || row.model);
+const sameModel = (row, route) => row.provider === route.provider && lower(rowId(row)) === lower(route.model);
+const effortsOf = (row) => (Array.isArray(row?.effortOptions) ? row.effortOptions.map((option) => option.value) : []);
+const choiceLabel = (row) => `${row.display || rowId(row)} (${row.provider}/${rowId(row)})`;
+
+function choices(rows) {
+  const shown = rows.slice(0, CHOICE_LIMIT).map(choiceLabel).join('; ');
+  return rows.length > CHOICE_LIMIT ? `${shown}; … (${rows.length} total)` : shown;
+}
+
+/** An effort level word ("max") or null; "auto" is no level. */
+function effortWord(word) {
+  try {
+    return normalizeEffortInput(word);
+  } catch {
+    return null;
+  }
+}
+
+/** The catalog rows of the model menu, read through session `sessionId`'s runtime. */
+export async function readModelCatalog(service, sessionId) {
+  const result = await service.readSession({ sessionId, action: 'listProviderModels', args: [{}] });
+  return Array.isArray(result?.value) ? result.value : [];
+}
+
+/** The route of a catalog display name (case-insensitive, exact), with a
+ *  trailing effort word ("Claude Opus 5.5 max", or auto) read as the effort
+ *  only when the whole text names no model. With `explicitEffort` the word
+ *  only selects the name: the caller applies its own effort. Throws with the
+ *  choices when the text names no model or several. */
+export function routeByDisplayName(text, rows, explicitEffort = false) {
+  const wanted = lower(text);
+  const cut = wanted.lastIndexOf(' ');
+  const word = cut > 0 ? wanted.slice(cut + 1) : '';
+  const suffix = word === 'auto' || effortWord(word) ? word : null;
+  let hits = rows.filter((row) => lower(row.display) === wanted);
+  let effort = null;
+  if (!hits.length && suffix) {
+    const base = wanted.slice(0, cut).trim();
+    hits = rows.filter((row) => lower(row.display) === base);
+    effort = suffix;
+  }
+  if (!hits.length) {
+    const words = wanted.split(/\s+/).filter(Boolean);
+    const near = rows.filter((row) => words.every((word) => lower(row.display).includes(word)));
+    throw new Error(
+      `session: model "${clean(text)}" is neither a provider/model route, a preset name nor a model display name. ` +
+        `Choices: ${choices(near.length ? near : rows)}${suffix ? '. To set the reasoning effort, pass it as the effort field' : ''}`
+    );
+  }
+  const distinct = [...new Map(hits.map((row) => [`${row.provider}/${rowId(row)}`, row])).values()];
+  if (distinct.length > 1) {
+    throw new Error(`session: model "${clean(text)}" is ambiguous; use provider/model: ${choices(distinct)}`);
+  }
+  const route = { provider: distinct[0].provider, model: rowId(distinct[0]) };
+  return effort && !explicitEffort ? withEffort(route, effort, rows) : route;
+}
+
+/** `route` with the effort level `value`, checked against the levels its
+ *  model supports ("auto" clears it). A chosen level turns the route's Auto
+ *  effort off, as the menu's effort pick does, or Auto would replace it. */
+export function withEffort(route, value, rows) {
+  const level = checkEffort(value, route, rows);
+  const { effort: _previous, ...rest } = route;
+  return level ? { ...rest, effort: level, autoEffort: false } : rest;
+}
+
+/** The effort level `value` names for `route` ("auto" is null); throws with
+ *  the model's levels when it is unknown or unsupported. */
+export function checkEffort(value, route, rows) {
+  const row = rows.find((candidate) => sameModel(candidate, route));
+  const allowed = row ? effortsOf(row) : null;
+  const offer = allowed
+    ? `; ${route.provider}/${route.model} supports: auto${allowed.map((level) => `, ${level}`).join('')}`
+    : '';
+  let level;
+  try {
+    level = normalizeEffortInput(value);
+  } catch (error) {
+    throw new Error(`session: ${error.message}${offer}`);
+  }
+  if (level && allowed && !allowed.includes(level)) {
+    throw new Error(`session: effort "${level}" is not supported${offer}`);
+  }
+  return level;
+}

package/src/session-runtime/tool-policy/policy-stage.mjs

@@ -18,7 +18,9 @@ import { sessionRolePromptFields } from '../../runtime/agent/orchestrator/sessio
 import {
   delegationDisabled,
   honoredSchemaAllowlist,
+  reactionDisabled,
 } from '../../runtime/agent/orchestrator/session/manager/session-tool-surface.mjs';
+import { REACTION_TOOL_NAME } from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 import { finalizeSessionToolList } from '../../runtime/agent/orchestrator/session/manager/tool-resolution.mjs';
 import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
 import { AGENT_MODE, sessionModeOf } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
@@ -40,14 +42,15 @@ export function createPolicyStage({
   activeWorkflowContext,
 }) {
   // The tools `session` is denied now: its caller's denials, the feature gates
-  // as they stand, and an agent-mode Lead's agent tool when its workflow
+  // as they stand, an agent-mode Lead's agent tool when its workflow
   // delegates to no one (a coding Lead keeps it: workflow.mjs
-  // workflowDisallowsAgentTool).
+  // workflowDisallowsAgentTool), and react outside a bot's chat with the user.
   function liveDeniedTools(session, workflow) {
     return [
       ...session.callerDisallowedTools,
       ...featureDisallowedTools(),
       ...(workflowDisallowsAgentTool(workflow, { agentMode: sessionModeOf(session) === AGENT_MODE }) ? ['agent'] : []),
+      ...(reactionDisabled(session, isAgentOwner(session)) ? [REACTION_TOOL_NAME] : []),
     ]
       .map((name) => String(name || ''))
       .filter(Boolean);

package/src/session-runtime/tool-policy/surface-helpers.mjs

@@ -2,7 +2,6 @@
 // rewriting its system blocks (BP1 heading, BP3 core), and the configs a
 // session's workflow and orchestration mode give.
 import { AGENT_MODE, resolveSessionMode, sessionModeOf } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
-import { MIXY_AGENT_ID } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { refreshSessionBp3Environment } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import { promptOrchestrationModeOf } from '../../runtime/agent/orchestrator/session/manager/orchestration-mode-switch-notice.mjs';
 import { sessionOrchestrationMode } from '../../runtime/shared/orchestration.mjs';
@@ -77,11 +76,11 @@ export function rewriteBp3Core(session, nextCore) {
 }
 
 // A Lead's workflow slices (orchestration, agent and contact catalogs) for its
-// mode, Mixy's with the contacts.
+// mode; an agent-mode Lead's contacts are every bot but itself.
 export function leadPartsFor(session, leadPromptParts) {
   return leadPromptParts({
     agentMode: sessionModeOf(session) === AGENT_MODE,
-    mixy: resolveSessionMode({ session }).agentId === MIXY_AGENT_ID,
+    agentId: resolveSessionMode({ session }).agentId,
   });
 }
 

package/src/session-runtime/tool-surface.mjs

@@ -18,6 +18,9 @@ import { workflowDisallowsAgentTool } from '../runtime/agent/orchestrator/runtim
 import { promptWorkflowOf } from '../runtime/agent/orchestrator/session/manager/workflow-switch-notice.mjs';
 import { configuredOrchestrationMode } from '../runtime/shared/orchestration.mjs';
 import { isAgentModeSession } from '../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { isAgentOwner } from '../runtime/agent/orchestrator/agent-owner.mjs';
+import { reactionDisabled } from '../runtime/agent/orchestrator/session/manager/session-tool-surface.mjs';
+import { REACTION_TOOL_NAME } from '../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 
 export function createToolSurface({
   mgr,
@@ -78,6 +81,7 @@ export function createToolSurface({
       ...disallowedModelToolNamesForProfile(profileCandidates, getToolProfile()),
       ...getFeatureDisallowedTools(),
       ...(workflowAllowsAgents() ? [] : [...agentToolNames]),
+      ...(reactionDisabled(session, isAgentOwner(session)) ? [REACTION_TOOL_NAME] : []),
     ];
   }
 

package/src/session-runtime/workflow-agents-api/agent-editor.mjs

@@ -1,4 +1,4 @@
-import { join } from 'node:path';
+import { dirname, isAbsolute, join, relative, sep } from 'node:path';
 import { createHash } from 'node:crypto';
 import {
   accessSync,
@@ -7,18 +7,19 @@ import {
   mkdirSync,
   readFileSync,
   readdirSync,
+  realpathSync,
   renameSync,
   rmSync,
   statSync,
 } from 'node:fs';
 import {
   holdsNoData,
-  parseJsonText,
   readJsonStateSync,
   writeFileAtomicSync,
   writeJsonAtomicSync,
 } from '../../runtime/shared/atomic-file.mjs';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { agentEntryFile, agentEntryPath, parseManifestText } from '../../runtime/agent/orchestrator/runtime-core/workflow/agents.mjs';
 import { hasOwn } from '../../runtime/shared/object.mjs';
 import { serializeFrontmatterDoc } from '../../runtime/shared/markdown-frontmatter.mjs';
 import { isHiddenAgent } from '../../runtime/agent/orchestrator/internal-agents.mjs';
@@ -79,9 +80,43 @@ import {
 
 const isFixedAgent = (id) => FIXED_AGENT_SLOTS.some((agent) => agent.id === id);
 const userDir = userDefinitionDir;
-const hasUserAgentFile = (dataDir, id) => existsSync(join(userDir(dataDir, id), 'AGENT.md'));
-// An archived (deleted) agent's AGENT.md, moved aside beside the tombstone:
-// no loader reads it, and restoring moves it back.
+// The entry file of the agent folder `dir`, exactly as the loader reads it
+// (agent.json `entry`, AGENT.md by default).
+const entryIn = (dir) => agentEntryPath(dir, readManifest(dir));
+const userEntryPath = (dataDir, id) => entryIn(userDir(dataDir, id));
+// An agent exists where its folder has an AGENT.md, as discovery lists it.
+const hasEntryFile = (dir) => existsSync(join(dir, 'AGENT.md'));
+const hasUserAgentFile = (dataDir, id) => hasEntryFile(userDir(dataDir, id));
+const leavesFolder = (rel) => rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel);
+// The file delete moves aside and restore moves back: the agent's entry when
+// it is named inside `dir` and its folder resolves inside too (a symlink as the
+// last part moves as the link alone), else HEAD's AGENT.md. An entry outside the
+// folder (`..`, or through a linked folder) is shared and never moved.
+const archivableEntry = (dir, entry) => {
+  try {
+    const rel = relative(dir, entry);
+    if (rel && !leavesFolder(rel) && !leavesFolder(relative(realpathSync(dir), realpathSync(dirname(entry))))) {
+      return entry;
+    }
+  } catch {
+    // an unresolvable folder holds no entry to move
+  }
+  return join(dir, 'AGENT.md');
+};
+// The entry file the editor may hand out to edit in place: it resolves (symlinks
+// followed) to a file inside its own agent folder, else null. The loader still
+// reads an entry outside; only the editable path is contained.
+const editablePathIn = (dir, path) => {
+  try {
+    return leavesFolder(relative(realpathSync(dir), realpathSync(path))) ? null : path;
+  } catch {
+    return null;
+  }
+};
+// An archived (deleted) agent's entry file, moved aside beside the tombstone
+// as `<entry>.archived`: no loader reads it, and restoring moves it back.
+const archivedEntryPath = (entryPath) => `${entryPath}.archived`;
+// The default entry's archive (all that HEAD wrote); a save clears it.
 const ARCHIVED_AGENT_FILE = 'AGENT.md.archived';
 
 // Frontmatter the editor does not show (e.g. `permission`), taken from the
@@ -123,15 +158,19 @@ const writeManifest = (file, manifest) => writeJsonAtomicSync(file, manifest, DE
 // no data (empty, or NUL-filled by a crash) or is not a JSON object.
 function readManifestStrict(file) {
   try {
-    const text = readFileSync(file, 'utf8');
-    if (holdsNoData(text)) return null;
-    const value = parseJsonText(text);
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    return readManifestFile(file);
   } catch {
     return null;
   }
 }
 
+// The same, but a file that cannot be read throws its error.
+function readManifestFile(file) {
+  const text = readFileSync(file, 'utf8');
+  if (holdsNoData(text)) return null;
+  return parseManifestText(text);
+}
+
 // A read-only agent.json is a standing refusal, not a transient lock: the
 // atomic write's rename onto it fails with EPERM and is retried for seconds,
 // synchronously on the host's event loop. Refuse it up front (one stat, no wait),
@@ -559,10 +598,16 @@ function definitionPresence({ dataDir, rootDir, stat }, agentIds) {
 // A definition folder's revision: a hash of the three files an editor writes.
 function definitionDirRevision(dir) {
   const hash = createHash('sha256');
-  for (const name of ['agent.json', 'AGENT.md', PERSONA_FILE]) {
+  const manifest = readManifest(dir);
+  const files = [
+    ['agent.json', join(dir, 'agent.json')],
+    [agentEntryFile(manifest), agentEntryPath(dir, manifest)],
+    [PERSONA_FILE, join(dir, PERSONA_FILE)],
+  ];
+  for (const [name, file] of files) {
     hash.update(`${name}\0`);
     try {
-      hash.update(readFileSync(join(dir, name)));
+      hash.update(readFileSync(file));
     } catch {
       hash.update('\u0001absent');
     }
@@ -660,13 +705,27 @@ function createAgentArchiveApi({
       await announceBotChange(dataDir);
       return { id, deleted: true, revertedToBuiltIn: Boolean(sourceFallback) };
     }
-    // A custom agent is archived: its AGENT.md (what makes it an agent
-    // anywhere) moves aside, the tombstone keeps the packaged copy of a
-    // starter from coming back, and the rest (agent.json: name and face,
-    // persona, memory, its model and on/off) stays for its archived chat —
-    // until restoreAgentDefinition brings it back or purgeAgentDefinition.
+    // A custom agent is archived: its entry file (AGENT.md, or the one its
+    // agent.json names; what makes it an agent anywhere) moves aside, the
+    // tombstone keeps the packaged copy of a starter from coming back, and the
+    // rest (agent.json: name and face, persona, memory, its model and on/off)
+    // stays for its archived chat — until restoreAgentDefinition brings it back
+    // or purgeAgentDefinition.
+    // AGENT.md always moves aside; an AGENT.md over an existing archive is
+    // refused, since the move would overwrite it. Another selected entry
+    // moves too when its own archive is free, and otherwise stays in place
+    // under the tombstone.
+    const agentFile = join(dir, 'AGENT.md');
+    const agentArchive = archivedEntryPath(agentFile);
+    if (existsSync(agentFile) && existsSync(agentArchive)) {
+      throw new Error(`agent "${id}" cannot be deleted: ${agentArchive} already exists; move or remove it first`);
+    }
+    const entry = archivableEntry(dir, entryIn(dir));
     mkdirSync(dir, { recursive: true });
-    if (existsSync(join(dir, 'AGENT.md'))) renameSync(join(dir, 'AGENT.md'), join(dir, ARCHIVED_AGENT_FILE));
+    if (existsSync(agentFile)) renameSync(agentFile, agentArchive);
+    if (entry !== agentFile && existsSync(entry) && !existsSync(archivedEntryPath(entry))) {
+      renameSync(entry, archivedEntryPath(entry));
+    }
     writeFileAtomicSync(join(dir, AGENT_DELETED_MARKER), 'deleted\n');
     clearAgentDefinitionCache(id);
     // The Leads listing it drop it from their roster from their next turn.
@@ -683,11 +742,22 @@ function createAgentArchiveApi({
     const dataDir = dataDirOf();
     if (!isArchivedAgent(dataDir, id)) throw new Error(`agent "${id}" is not deleted`);
     const dir = userDir(dataDir, id);
-    const kept = join(dir, ARCHIVED_AGENT_FILE);
-    if (!existsSync(kept) && !existsSync(join(shippedDir(id), 'AGENT.md'))) {
+    // AGENT.md.archived back to AGENT.md, and the selected entry's archive back
+    // to that entry. Nothing is overwritten: an archive whose file exists again
+    // stays as it is, and when every kept archive collides the restore is refused.
+    const agentFile = join(dir, 'AGENT.md');
+    const entry = archivableEntry(dir, entryIn(dir));
+    const moves = [{ from: join(dir, ARCHIVED_AGENT_FILE), to: agentFile }];
+    if (entry !== agentFile) moves.push({ from: archivedEntryPath(entry), to: entry });
+    const kept = moves.filter((move) => existsSync(move.from));
+    if (kept.length === 0 && !hasEntryFile(shippedDir(id))) {
       throw new Error(`agent "${id}" was deleted before deleted agents were kept, so it cannot be restored`);
     }
-    if (existsSync(kept)) renameSync(kept, join(dir, 'AGENT.md'));
+    const free = kept.filter((move) => !existsSync(move.to));
+    if (kept.length > 0 && free.length === 0) {
+      throw new Error(`agent "${id}" cannot be restored: ${kept[0].to} already exists; move or remove it first`);
+    }
+    for (const move of free) renameSync(move.from, move.to);
     rmSync(join(dir, AGENT_DELETED_MARKER), { force: true });
     clearAgentDefinitionCache(id);
     // Back in the roster of the Leads that list it, from their next turn.
@@ -795,13 +865,20 @@ export function createAgentEditorApi(deps) {
     const dataDir = resolveDataDir(deps);
     const definition = loadAgentDefinition(dataDir, id);
     if (!definition) throw new Error(`agent "${agentId}" not found`);
+    const userOverride = hasUserAgentFile(dataDir, id);
     return {
       id,
       name: definition.name,
       description: definition.description,
       body: definition.body,
       custom: !isFixedAgent(id),
-      userOverride: hasUserAgentFile(dataDir, id),
+      userOverride,
+      // The user copy's entry file, editable in place; a shipped-only agent has
+      // none (an install-dir edit would be lost on update), nor has an entry
+      // that resolves outside its folder (the body is still returned).
+      ...(userOverride && editablePathIn(userDir(dataDir, id), userEntryPath(dataDir, id))
+        ? { path: userEntryPath(dataDir, id) }
+        : {}),
       route: routeFor(getConfig(), id),
       routeConfigured: routeConfigured(getConfig(), id),
       kind: kindOf(definition),

package/src/session-runtime/workflow-agents-api/workflow-packs.mjs

@@ -77,13 +77,18 @@ export function createWorkflowPacksApi(deps) {
     const dataDir = resolveDataDir(deps);
     const pack = loadWorkflowPack(dataDir, id);
     if (!pack || pack.id !== id) throw new Error(`workflow "${workflowId}" not found`);
+    // The user copy's file, so a part of a long body can be edited in place;
+    // a shipped-only pack has none (its install copy is replaced on update).
+    const file = join(dataDir, 'workflows', id, 'WORKFLOW.md');
+    const userOverride = existsSync(file);
     return {
       id: pack.id,
       name: pack.name,
       description: pack.description,
       source: pack.source,
       body: pack.body,
-      userOverride: existsSync(join(dataDir, 'workflows', id, 'WORKFLOW.md')),
+      userOverride,
+      ...(userOverride ? { path: file } : {}),
     };
   }
 

package/src/session-runtime/workspace/transitions.mjs

@@ -426,7 +426,7 @@ export function createWorkspaceTransitions({
    * refuses while a session or worker runs in an affected folder, or a
    * background command does; `removing` refuses while any session still uses
    * one. Then holds the folders — Mixdog checkouts only; an external checkout
-   * is never lock-blocked — so new Mixdog work there waits until `run`
+   * takes no lease from this profile — so new Mixdog work there waits until `run`
    * settles. `actor`: the session acting on its own checkout, whose own turn
    * and workers its caller already checked (assertLeadIdle).
    */
@@ -985,7 +985,15 @@ export function createWorkspaceTransitions({
    * `ownTurn` (internal: the Lead's own tool call) tolerates the calling turn.
    */
   async function requestWorktree(
-    { name = null, confirmLarge = false, provision = false, carryChanges, prompt = '', txId = '', expectedRevision } = {},
+    {
+      name = null,
+      confirmLarge = false,
+      provision = false,
+      carryChanges,
+      prompt = '',
+      txId = '',
+      expectedRevision,
+    } = {},
     { ownTurn = false } = {}
   ) {
     const nameHint = validName(name);