mixdog 1.3.0 → 1.3.1

package/src/session-runtime/model-route/route-tuning.mjs

@@ -10,7 +10,13 @@ export function createRouteTuning(deps, persist) {
   const { getConfig, getRoute, setRouteState, resolveRoute, lookupModelMeta, refreshRouteEffort } = deps;
 
   /** Save the live route's modelSettings, re-resolve through the lead preset
-   *  when one exists, refresh effort and tune the current session. */
+   *  when one exists, refresh effort and tune the current session.
+   *
+   *  This is not a Main-model write and needs no compare-and-set: it persists
+   *  the LIVE route (read after every await), and only when that route's model
+   *  is already the Main model (persistAdoptedModelSettings: tunesNonMainModel),
+   *  so the lead preset's model is rewritten with itself and never changes. A
+   *  live route without a model normalizes to nothing and writes no preset. */
   async function commitRouteTuning(fastCapable, modelMeta) {
     persist.saveRouteModelSettings(getRoute(), fastCapable);
     const leadRoute = persist.persistAdoptedModelSettings(getRoute());

package/src/session-runtime/model-route/set-route.mjs

@@ -195,9 +195,23 @@ async function adoptRoute(deps, persist, next, options, lease) {
     scheduleStatuslineUsageRefresh,
   } = deps;
   const { selectedRoute, fastCapable, modelMeta } = await resolveSelectedRoute(deps, next);
+  // The Lead route a conditional fill wrote, until the file confirms it.
+  let filled = null;
   // Provider readiness may outlast the session the selection was made for.
   const adopted = lease.run(
     () => {
+      // Compare-and-set: a route that already has a model (picked while this
+      // selection was resolving) is never replaced. Checked synchronously with
+      // the adopt below, so nothing can set a route in between. A Lead route
+      // another process persisted may not have reached this runtime yet (the
+      // change notification is debounced): the config is re-read from disk
+      // right here, which adopts it and fills the empty route, and that route
+      // is the winner this selection answers with.
+      if (options?.onlyIfEmpty === true) {
+        if (clean(getRoute()?.model)) return false;
+        deps.reloadFullConfig?.();
+        if (clean(getRoute()?.model)) return false;
+      }
       if (options?.sessionOnly === true) {
         // An agent child's route belongs to that session alone: the shared
         // modelSettings bucket (saved effort/Fast per model) and the main
@@ -210,7 +224,9 @@ async function adoptRoute(deps, persist, next, options, lease) {
         // — the session surface's model pick, an heir — keeps it.
         const leadRoute = persist.persistAdoptedModelSettings(selectedRoute, {
           keepMainModel: options?.keepMainModel !== false,
+          onlyIfAbsent: options?.onlyIfEmpty === true,
         });
+        filled = leadRoute;
         setRouteState(resolveRoute(getConfig(), leadRoute ? { model: workflowPresetId('lead') } : selectedRoute));
       }
       return true;
@@ -218,9 +234,13 @@ async function adoptRoute(deps, persist, next, options, lease) {
     () => false
   );
   if (!adopted) return false;
+  // A conditional fill reaches the file only while no Lead route is stored
+  // there (judged under the config file lock). When another process wrote one
+  // after the re-read above, the file's route replaces the fill in the runtime.
+  const replaced = filled && (await deps.confirmLeadFill?.(filled)) === true;
   // The refresh completes against the route just adopted and only while the
   // selection still owns it.
-  await refreshRouteEffort(modelMeta, getRoute(), null, lease);
+  await refreshRouteEffort(replaced ? null : modelMeta, getRoute(), null, lease);
   return lease.run(
     () => {
       refreshStatuslineUsageSnapshot(getRoute());

package/src/session-runtime/native-web-search.mjs

@@ -14,7 +14,7 @@ import {
 } from './native-web-search/tool-shape.mjs';
 import { createWebSearchRouteCandidates } from './native-web-search/routes.mjs';
 import { reportNativeWebSearchUsage } from './native-web-search-usage.mjs';
-import { canFallbackRoute } from '../runtime/shared/model-route-fallback.mjs';
+import { canFallbackCapacityRoute } from '../runtime/shared/model-route-fallback.mjs';
 
 export function createNativeWebSearch(deps) {
   const {
@@ -103,7 +103,7 @@ export function createNativeWebSearch(deps) {
       try {
         return await sendCandidate(candidate, toolType, webSearchArgs, signal);
       } catch (err) {
-        if (!canFallbackRoute(err, { signal })) throw err;
+        if (!canFallbackCapacityRoute(err, { signal })) throw err;
         errors.push(
           `${candidate.provider}${candidate.model ? `/${candidate.model}` : ''}/${toolType}: ${err?.message || String(err)}`
         );

package/src/session-runtime/new-session-config.mjs

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from 'node:util';
+import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { flushPendingSessionConfigWrites } from './config-lifecycle.mjs';
 
 // Run only after the lifecycle has established that it needs a NEW session.
@@ -27,7 +28,11 @@ export function createNewSessionConfig({
     if (!initialConfig || typeof initialConfig !== 'object') {
       reloadFullConfig();
       if (!firstSession || !initialRouteExplicit) {
-        rt.route = resolveRoute(rt.config, {});
+        const configured = resolveRoute(rt.config, {});
+        // With no Lead model configured the model picked for this runtime's
+        // still-empty conversation (a session-only choice never writes the
+        // Lead route) stands; the reload must not drop it before the first turn.
+        if (clean(configured?.model) || !clean(rt.route?.model)) rt.route = configured;
       }
     }
     invalidateOutputStyleStatusCache();

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

@@ -1,5 +1,5 @@
-// Route resolution against the live runtime record: pick a model for a
-// model-less first turn and refresh the route's effort / Fast / context
+// Route resolution against the live runtime record: refuse a model-less first
+// turn (no auto-pick) and refresh the route's effort / Fast / context
 // fields from provider metadata.
 import { ensureProviderEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
@@ -22,17 +22,11 @@ export function createRouteResolution({ rt, collectProviderModels, ensureProvide
     if (routeHasModel()) return rt.route;
     const models = await runAbortable(signal, () => collectProviderModels());
     throwIfAborted(signal);
-    const picked = models[0] || null;
-    if (!picked) {
+    if (!models?.length) {
       throw new Error('No provider models available. Open /providers to sign in, then /model to choose a model.');
     }
-    rt.route = {
-      ...rt.route,
-      provider: picked.provider,
-      model: picked.id,
-      preset: null,
-    };
-    return rt.route;
+    // Never auto-pick: the user chooses the model.
+    throw new Error('No model selected. Choose a model with /model first.');
   }
 
   async function refreshRouteEffort(modelMetaOverride = null, expectedRoute = null, signal = null, lease = null) {

package/src/session-runtime/services/agent-tool/helpers.mjs

@@ -12,6 +12,8 @@ import {
 import { PRESET_ALIASES } from './tool-def.mjs';
 import { positiveInt } from '../../../runtime/shared/numbers.mjs';
 import { clean } from '../../../runtime/shared/clean.mjs';
+import { readAgentDefinitionKind } from '../../../runtime/shared/agent-kind.mjs';
+import { isStoreBot, userDefinitionDir } from '../../../runtime/shared/agent-store.mjs';
 import { normalizeContextTokens } from '../../../runtime/shared/llm/default-context-window.mjs';
 
 export { positiveInt };
@@ -300,13 +302,18 @@ const _frontmatterPermCache = new Map(); // key -> { value, atMs }
 const FRONTMATTER_PERM_CACHE_TTL_MS = envTimeoutMs('MIXDOG_AGENT_FRONTMATTER_TTL_MS', 5_000);
 
 function agentDeleted(cleanAgent, dataDir) {
-  return Boolean(dataDir) && existsSync(join(dataDir, 'agents', cleanAgent, '.deleted'));
+  return Boolean(dataDir) && existsSync(join(userDefinitionDir(dataDir, cleanAgent), '.deleted'));
 }
 
 /** Where an agent's definition may live, in precedence order: the data dir
  *  (user/custom agents) before the shipped source root. */
 function agentDefinitionFiles(cleanAgent, dataDir, standaloneSourceRoot) {
   const candidates = [];
+  if (dataDir && isStoreBot(dataDir, cleanAgent)) {
+    // A bot of the store: only its own folder (never the agents/ original).
+    candidates.push(join(userDefinitionDir(dataDir, cleanAgent), 'AGENT.md'));
+    return candidates;
+  }
   if (dataDir) {
     candidates.push(join(dataDir, 'agents', cleanAgent, 'AGENT.md'));
     candidates.push(join(dataDir, 'agents', `${cleanAgent}.md`));
@@ -353,13 +360,25 @@ export function readAgentFrontmatterPermission(agent, dataDir, standaloneSourceR
 }
 
 const _frontmatterKindCache = new Map(); // key -> { value, atMs }
+const _frontmatterKindValueCache = new Map(); // key -> { value, atMs }
 
-/** The agent definition's frontmatter `kind` (isContactAgentId reads it), or
- *  null when it sets none. */
+/** The agent definition's kind (isContactAgentId reads it), by the one
+ *  read-only rule (agent-kind.mjs), cached per agent for the frontmatter TTL. */
 export function readAgentFrontmatterKind(agent, dataDir, standaloneSourceRoot) {
-  return cachedFrontmatterValue(_frontmatterKindCache, agent, dataDir, standaloneSourceRoot, (fm) =>
-    typeof fm.kind === 'string' && fm.kind.trim() ? fm.kind.trim() : null
+  const id = clean(agent);
+  if (!id || agentDeleted(id, dataDir)) return null;
+  const cacheKey = `${dataDir}\u0000${id}`;
+  const cached = _frontmatterKindCache.get(cacheKey);
+  if (cached && Date.now() - cached.atMs < FRONTMATTER_PERM_CACHE_TTL_MS) return cached.value;
+  // An explicit kind in the definition in effect (any layout) wins; only an
+  // unmarked user copy goes to the evidence rule.
+  const explicit = cachedFrontmatterValue(_frontmatterKindValueCache, id, dataDir, standaloneSourceRoot, (fm) =>
+    typeof fm.kind === 'string' && fm.kind.trim() ? fm.kind.trim().toLowerCase() : null
   );
+  const value =
+    explicit || (dataDir ? readAgentDefinitionKind({ dataDir, shippedRoot: standaloneSourceRoot, id }) : null);
+  _frontmatterKindCache.set(cacheKey, { value, atMs: Date.now() });
+  return value;
 }
 
 /** The agent definition's `firstResponseTimeoutMs` (a non-negative integer;

package/src/session-runtime/services/agent-tool/send-flow.mjs

@@ -16,6 +16,7 @@ import {
   terminalResultHook,
 } from './job-task-reconcile.mjs';
 import { createTurnReviewCollector } from './turn-review.mjs';
+import { handoffContent } from '../../handoff-attachments.mjs';
 import { settledWorkerStatus } from './worker-index/row-liveness.mjs';
 
 // `send` to an existing worker: resolve the live session, run one follow-up
@@ -69,8 +70,10 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     return hooks;
   }
 
-  function runTurn({ session, sessionId, prompt, args }, turnHooks) {
+  function runTurn({ session, sessionId, prompt: text, args }, turnHooks) {
     const cwd = session.cwd || defaultCwd;
+    // The caller's forwarded files ride along as attachment parts.
+    const prompt = handoffContent(text, args.attachmentParts);
     if (canUseSessionSurface(session)) {
       return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd, ...turnHooks });
     }
@@ -194,7 +197,11 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     const { session, sessionId, prompt } = prepared;
     const tag = registry.tagForSession(sessionId);
     if (canUseSessionSurface(session) && views.isSessionBusy(sessionId)) {
-      const queued = await sessionSurface.enqueueTurn({ session, prompt, context: prepared.args.context || null });
+      const queued = await sessionSurface.enqueueTurn({
+        session,
+        prompt: handoffContent(prompt, prepared.args.attachmentParts),
+        context: prepared.args.context || null,
+      });
       if (queued) {
         return renderResult({ queued: true, ...extras, tag, sessionId, agent: session.agent || null, ...queued });
       }
@@ -204,7 +211,8 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       views.isSessionBusy(sessionId) &&
       typeof mgr.enqueuePendingMessage === 'function'
     ) {
-      const queueDepth = mgr.enqueuePendingMessage(sessionId, prompt);
+      // The queued follow-up keeps the forwarded files, as the canonical queue does.
+      const queueDepth = mgr.enqueuePendingMessage(sessionId, handoffContent(prompt, prepared.args.attachmentParts));
       return renderResult({ queued: true, ...extras, tag, sessionId, agent: session.agent || null, queueDepth });
     }
     const job = spawnFlow.startJob(

package/src/session-runtime/services/agent-tool/spawn-flow/spawn-run.mjs

@@ -25,6 +25,7 @@ import { settledWorkerStatus } from '../worker-index/row-liveness.mjs';
 import { saveSessionAsync } from '../../../../runtime/agent/orchestrator/session/store.mjs';
 import { presetDescriptor } from './spawn-prep.mjs';
 import { workerStageForStatus } from '../worker-rows.mjs';
+import { handoffContent } from '../../../handoff-attachments.mjs';
 
 // Mid-turn worker persistence cadence. The watchdog sweep runs every second;
 // a transcript save is far more expensive than a bookkeeping stamp, so the
@@ -117,7 +118,9 @@ export function createSpawnRunner({
   };
 
   async function runTurn(prepared, turnHooks) {
-    const { args, session, prompt, workerCwd } = prepared;
+    const { args, session, workerCwd } = prepared;
+    // The caller's forwarded files ride along as attachment parts.
+    const prompt = handoffContent(prepared.prompt, args.attachmentParts);
     if (typeof sessionSurface?.runTurn === 'function' && sessionSurface.canRun?.(session) !== false) {
       return sessionSurface.runTurn({ session, prompt, context: args.context || null, cwd: workerCwd, ...turnHooks });
     }

package/src/session-runtime/services/agent-tool/spawn-preset.mjs

@@ -27,11 +27,10 @@ export function resolveAgentSpawnPreset(config, args = {}) {
   }
 
   const agentName = normalizeAgentName(args.agent);
-  const agentRoute = !clean(args.preset)
-    ? configuredAgentRouteCandidates(config, agentName)
-        .map((candidate) => normalizeAgentRoute(candidate))
-        .find(Boolean) || null
-    : null;
+  // The agent's stored route: config.agents, or a store bot's own folder.
+  const candidates = !clean(args.preset) ? configuredAgentRouteCandidates(config, agentName) : [];
+  const agentRoute = candidates.map((candidate) => normalizeAgentRoute(candidate)).find(Boolean) || null;
+  const storedFallbacks = candidates.find((candidate) => normalizeAgentRoute(candidate))?.fallbacks;
   if (agentRoute) {
     return {
       presetName: agentPresetName(agentName),
@@ -41,9 +40,7 @@ export function resolveAgentSpawnPreset(config, args = {}) {
         type: 'agent',
         provider: agentRoute.provider,
         model: agentRoute.model,
-        ...(config.agents?.[agentName]?.fallbacks?.length
-          ? { fallbacks: config.agents[agentName].fallbacks.map(normalizeAgentRoute) }
-          : {}),
+        ...(storedFallbacks?.length ? { fallbacks: storedFallbacks.map(normalizeAgentRoute) } : {}),
         effort: agentRoute.effort,
         fast: agentRoute.fast === true,
         ...(agentRoute.autoEffort === false ? { autoEffort: false } : {}),

package/src/session-runtime/services/agent-tool/tool-def.mjs

@@ -53,6 +53,13 @@ export const AGENT_TOOL = {
       file: { type: 'string', description: 'Path to task text; alternative to prompt/message for spawn/send.' },
       cwd: { type: 'string', description: 'Project directory for a new or respawned agent.' },
       context: { type: 'string', description: 'Extra context for the spawn/send turn.' },
+      attachments: {
+        type: 'array',
+        items: { type: 'string' },
+        maxItems: 8,
+        description:
+          "spawn/send: files to attach (images, PDF/Office, text): a conversation attachment's file name or [attachment:id], or a path inside your folders. Produced files come back as paths; forward them by path.",
+      },
       model: {
         type: 'string',
         description:

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

@@ -377,6 +377,17 @@ const SETUP_STATUS_READERS = {
 // schema, the per-action field list and the route/object-argument minimums.
 function validateSetupInput(args) {
   const action = requireEnum(args?.action, SETUP_ACTIONS, 'action');
+  // Old callers still ask to connect GitHub: it is the signed-in GitHub CLI, not a catalog connector.
+  if (
+    action === 'connect_connector' &&
+    String(args.connector ?? '')
+      .trim()
+      .toLowerCase() === 'github'
+  ) {
+    throw new Error(
+      'GitHub uses the signed-in GitHub CLI; no connector needed. Use the github tool or Settings → Git.'
+    );
+  }
   const validationError = schemaValueError({ ...args, action }, SETUP_TOOL_DEFS[0].inputSchema, 'setup');
   if (validationError) throw new Error(`[tool-input-validation] ${validationError}`);
   const fields = SETUP_ACTION_FIELDS[action].split(' ').filter(Boolean);
@@ -647,7 +658,7 @@ const SETUP_ACTION_HANDLERS = {
     const entry = connectorById(requireText(args.connector, 'connector'));
     if (!entry || entry.ownKey) throw new Error(`connector must be one of ${CONNECTOR_IDS.join(', ')}`);
     const server = (rt.mcpStatus?.()?.servers || []).find((row) => row.connector === entry.id) || null;
-    const connected = entry.backend.kind === 'builtin' ? null : server?.connected === true;
+    const connected = server?.connected === true;
     return {
       connector: entry.id,
       name: entry.name,

package/src/session-runtime/setup-tool/extended-actions.mjs

@@ -1,7 +1,9 @@
 import { SETUP_EXTENDED_PROPERTIES, SETUP_DESKTOP_ACTIONS } from './settings-contract.mjs';
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { OPENAI_COMPAT_PRESETS } from '../../runtime/agent/orchestrator/providers/openai-compat-presets.mjs';
-import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { MIXY_AGENT_ID, agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { AGENT_MODE, resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { BOT_AGENT_KIND, WORKFLOW_AGENT_KIND } from '../../runtime/shared/agent-route-config.mjs';
 import { assertAutomationAccess, scheduleCallerScope } from '../services/schedule-access.mjs';
 
 const own = (value, key) => Object.hasOwn(value || {}, key);
@@ -164,13 +166,20 @@ async function readDefinition(rt, kind, name) {
   };
 }
 
-async function saveDefinition(rt, args) {
+// A created agent's explicit marker: the one given, else a bot when Mixy's
+// agent-mode chat creates it (Mixy creates bots), else a workflow agent.
+function createdAgentKind(input, caller) {
+  if (own(input, 'kind')) return input.kind;
+  const { mode, agentId } = resolveSessionMode({ session: caller });
+  return mode === AGENT_MODE && agentId === MIXY_AGENT_ID ? BOT_AGENT_KIND : WORKFLOW_AGENT_KIND;
+}
+
+async function saveDefinition(rt, args, context = {}) {
   const kind = args.definitionKind;
   const input = args.definition;
-  const allowed =
-    kind === 'skill'
-      ? ['originalName', 'name', 'description', 'body', 'whenToUse', 'toolDependencies']
-      : ['id', 'name', 'description', 'body'];
+  let allowed = ['id', 'name', 'description', 'body'];
+  if (kind === 'skill') allowed = ['originalName', 'name', 'description', 'body', 'whenToUse', 'toolDependencies'];
+  else if (kind === 'agent') allowed = [...allowed, 'kind'];
   const unexpected = Object.keys(input).find((key) => !allowed.includes(key));
   if (unexpected) throw new Error(`${unexpected} is not a ${kind} definition field`);
   const creating = args.action === 'create_definition';
@@ -200,7 +209,10 @@ async function saveDefinition(rt, args) {
       const agents = await rt.listAgents();
       if (agents.some((agent) => agent.id === input.id)) throw new Error(`agent "${input.id}" already exists`);
     }
-    return rt.saveAgentDefinition(creating ? next : { ...next, id: current.id });
+    if (creating) return rt.saveAgentDefinition({ ...next, kind: createdAgentKind(input, context.caller) });
+    // The stored kind is kept as it is; an edit naming one is refused by the editor.
+    const { kind: _storedKind, ...edit } = { ...pick(current, definitionKeys), ...input };
+    return rt.saveAgentDefinition({ ...edit, ...(own(input, 'kind') ? { kind: input.kind } : {}), id: current.id });
   }
   return creating ? rt.addSkill(next) : rt.saveSkill({ ...next, originalName: current.originalName });
 }

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

@@ -157,6 +157,12 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     name: text,
     description: text,
     body: text,
+    kind: {
+      type: 'string',
+      enum: ['bot', 'agent'],
+      description:
+        'Agent create only: "bot" (a contact the user chats with) or "agent" (a workflow sub-agent). Omitted: a bot when created from the representative bot\'s chat, else a workflow agent. Fixed after creation.',
+    },
     whenToUse: text,
     toolDependencies: {
       type: ['array', 'null'],

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

@@ -343,7 +343,17 @@ export function createToolPolicyRefresh({
         to: session.workflow.name,
         at: Date.now(),
       };
-      recordTranscriptBoundary(session, 'workflowSwitches', workflowSwitch, (entry) => entry?.at === workflowSwitch.at);
+      // Two switches can land in the same millisecond (A→B→A): the same
+      // switch is a repeat only when its direction matches too.
+      recordTranscriptBoundary(
+        session,
+        'workflowSwitches',
+        workflowSwitch,
+        (entry) =>
+          entry?.at === workflowSwitch.at &&
+          entry?.fromId === workflowSwitch.fromId &&
+          entry?.toId === workflowSwitch.toId
+      );
     }
     return { appliedToCurrentSession: true, workflow: session.workflow, workflowSwitch };
   }
@@ -369,7 +379,8 @@ export function createToolPolicyRefresh({
     const identity = session?.promptIdentity;
     const agent = identity?.agent;
     if (!session?.id || !agent || isAgentOwner(session)) return false;
-    const revision = agentProfileRevision(agent);
+    // Only Mixy's own (agent-mode) thread embeds Mixy's profile.
+    const revision = agentProfileRevision(agent, { mixy: sessionModeOf(session) === AGENT_MODE });
     const config = getConfig();
     const workflowId = session.workflow?.id;
     const workflowConfig = workflowId

package/src/session-runtime/turn/turn-run/turn-prepare.mjs

@@ -10,6 +10,8 @@ import { throwIfAborted } from '../../../runtime/shared/abort-race.mjs';
 // UserPromptSubmit hook.
 export function createTurnPreparation({
   getSession,
+  setSession,
+  mgr,
   getCurrentCwd,
   awaitRoutePreparation,
   createCurrentSession,
@@ -105,6 +107,15 @@ export function createTurnPreparation({
     }
     throwIfAborted(turn.signal);
     assertSessionAdmission?.();
+    // askSession runs the turn on the session the store serves for this id.
+    // While this runtime idled, the store's idle sweep may have released the
+    // snapshot it holds, and the store then serves a fresh parse of the file:
+    // preparing the turn on the held copy would leave its one-shot work (the
+    // first-turn MCP fold, its flag) undone on the turn's session, which then
+    // rewrites the prompt it already sent on the next turn. Prepare the turn
+    // on the session it runs on (as completeTurn adopts it afterwards).
+    const stored = mgr.getSession(getSession().id);
+    if (stored && stored !== getSession()) setSession(stored);
     // Turn admission: waits while this session's workspace transitions or
     // another session changes the checkout this session works in, then holds
     // the turn registered (released by settleTurn) so no checkout changes