mixdog 1.1.2 → 1.2.1

package/src/runtime/agent/orchestrator/session/loop/steering.mjs

@@ -1,5 +1,6 @@
 // Steering-message normalization/merge helpers.
 // Merges queued steering entries into a single content payload + display text.
+import { stableMessageId } from '../../../../shared/transcript-metadata.mjs';
 
 function steeringContentText(content) {
   if (typeof content === 'string') return content;
@@ -135,10 +136,14 @@ function injectSteeringEntry(merged, { messages, opts, stage, onSkillPrompt }) {
   const rawSubmittedAt = Number(merged.submittedAt);
   const submittedAt = Number.isFinite(rawSubmittedAt) && rawSubmittedAt > 0 ? rawSubmittedAt : undefined;
   const injectedAt = Date.now();
+  // Every steered message carries a stable id from creation; the surface
+  // gets it back (onSteerMessage) for the row it draws. A steered prompt
+  // keeps the id the surface gave it, else gets one.
+  const messageId = stableMessageId(merged.transcriptMeta?.messageId);
   const steeringTranscriptMeta =
     merged.transcriptMeta && typeof merged.transcriptMeta === 'object'
-      ? { at: submittedAt ?? injectedAt, ...merged.transcriptMeta }
-      : null;
+      ? { at: submittedAt ?? injectedAt, ...merged.transcriptMeta, messageId }
+      : { messageId };
   // Tag steering-origin user messages so provider lowering keeps them
   // distinct from preceding tool results. Keep each queued command as
   // its own user turn instead of collapsing priority/mode buckets
@@ -151,17 +156,18 @@ function injectSteeringEntry(merged, { messages, opts, stage, onSkillPrompt }) {
   const notification = merged.mode === 'task-notification';
   const execution =
     notification && merged.execution && typeof merged.execution === 'object' ? { ...merged.execution } : null;
-  messages.push({
+  const message = {
     role: 'user',
     content: merged.content,
     meta: {
       source: notification ? 'task-notification' : 'steering',
       ...(execution ? { execution } : {}),
       ...(submissionIds.length ? { submissionIds } : {}),
-      ...(steeringTranscriptMeta ? { transcript: steeringTranscriptMeta } : {}),
+      transcript: steeringTranscriptMeta,
     },
-  });
-  if (!notification) onSkillPrompt(merged.content);
+  };
+  messages.push(message);
+  if (!notification) onSkillPrompt(merged.content, message);
   const text = merged.text || steeringContentText(merged.content);
   try {
     opts.onSteerMessage?.(text, {
@@ -172,9 +178,12 @@ function injectSteeringEntry(merged, { messages, opts, stage, onSkillPrompt }) {
       ...(notification ? { mode: 'task-notification' } : {}),
       ...(execution ? { execution } : {}),
       ...(Array.isArray(merged.images) && merged.images.length ? { images: merged.images } : {}),
-      ...(steeringTranscriptMeta ? { transcriptMeta: steeringTranscriptMeta } : {}),
+      transcriptMeta: steeringTranscriptMeta,
+      messageId,
     });
-  } catch {}
+  } catch {
+    /* best-effort host callback */
+  }
   return {
     count: Number(merged.count) || 1,
     textLength: String(text || '').length,
@@ -224,9 +233,11 @@ export function createSteeringDrain({ messages, opts, sessionId, onSkillPrompt }
       try {
         process.stderr.write(
           `[steer] sess=${sessionId} injected ${stage} user message(s)` +
-            ` (merged=${totalCount} len=${totalTextLen} waitMs=${Math.max(0, maxQueueWaitMs)})\n`
+            ` (merged=${totalCount} len=${totalTextLen} waitMs=${maxQueueWaitMs})\n`
         );
-      } catch {}
+      } catch {
+        /* best-effort diagnostics */
+      }
     }
     return true;
   };

package/src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs

@@ -12,6 +12,8 @@ import {
   filterSkillsExcludingDisabled,
   isSkillDisabled,
   skillMissingFeature,
+  skillOutsideScope,
+  skillOutsideScopeError,
 } from '../../context/collect.mjs';
 
 // Eager-dispatch: tools with readOnlyHint:true in their declaration are safe
@@ -96,6 +98,7 @@ export function viewSkill(cwd, name, session = null) {
     return `Error: skill "${skillName}" needs the ${missingFeature} built-in feature, which is not installed or is switched off in Extensions → Plugin → Built-in`;
   }
   if (isSkillDisabled(skillName)) return `Error: skill "${skillName}" is disabled`;
+  if (skillOutsideScope(skillName, cwd)) return skillOutsideScopeError(skillName);
   const res = loadSkillResource(skillName, cwd);
   if (!res) return `Error: skill "${skillName}" not found`;
   // Return the general tool envelope: the model-visible tool_result is the

package/src/runtime/agent/orchestrator/session/loop/usage.mjs

@@ -40,6 +40,7 @@ export function usageDeltaEvent({
   model,
   usage,
   sendTools,
+  toolCalls = 0,
 }) {
   return {
     sessionId,
@@ -51,6 +52,8 @@ export function usageDeltaEvent({
     usageMetricsEpoch,
     deltaInput: usage.inputTokens || 0,
     deltaOutput: usage.outputTokens || 0,
+    // Tool calls this response dispatched; the session's cumulative count.
+    deltaToolCalls: toolCalls,
     ...reasoningUsage(usage),
     deltaPrompt: usage.promptTokens || 0,
     // Cache delta carried alongside input/output so live metrics reflect

package/src/runtime/agent/orchestrator/session/manager/ask-queue.mjs

@@ -12,6 +12,17 @@ import {
 
 const SYNTHETIC_PROMPT_SOURCES = ['goal-continuation', 'goal-closeout'];
 
+// A caller-declared prompt source the runtime trusts as provenance of the
+// initial prompt: Goal turns are runtime-synthetic; a task notification (an
+// idle-drained completion, an automation run's agent results) is stored like
+// one the steering/queue drains inject, never as the user speaking — so none
+// of these run explicit skill selection.
+function initialPromptSourceFor(promptSource) {
+  if (SYNTHETIC_PROMPT_SOURCES.includes(promptSource)) return { source: promptSource, synthetic: true };
+  if (promptSource === PENDING_MODE_TASK_NOTIFICATION) return { source: promptSource };
+  return null;
+}
+
 /** Prompt provenance for a drained queue turn: the source plus its execution when one exists. */
 const promptSourceFields = (source, execution) => {
   if (!source) return null;
@@ -42,9 +53,7 @@ export function createAskPromptQueue({ sessionId, promptSource }) {
   // Local FIFO of follow-up prompts drained from the pending-message queue
   // after each turn — keeps queued `agent type=send` messages in order.
   const tail = [];
-  let initialPromptSource = SYNTHETIC_PROMPT_SOURCES.includes(promptSource)
-    ? { source: promptSource, synthetic: true }
-    : null;
+  let initialPromptSource = initialPromptSourceFor(promptSource);
 
   /** The next turn's input — prompt, caller context, consumed queue entries
    *  and provenance — or null when nothing model-visible is left to run. */

package/src/runtime/agent/orchestrator/session/manager/ask-session.mjs

@@ -40,13 +40,23 @@ const traceAskStart = (sessionId, explicitPrefetch) => {
 
 /** The transcript timestamps the caller supplied for this ask: the persisted
  *  user metadata plus a one-shot reader for the assistant metadata. */
-function createAskTranscriptMeta(rawTranscriptMeta) {
+export function createAskTranscriptMeta(rawTranscriptMeta) {
   return {
     raw: rawTranscriptMeta,
     user: persistedUserTranscriptMetadata(rawTranscriptMeta),
     takeAssistant: () => {
+      const live = rawTranscriptMeta && typeof rawTranscriptMeta === 'object';
+      // An id the live row already minted is the one persisted; otherwise the
+      // row has not been drawn yet and takes this message's id and time.
+      const rowKnowsId =
+        live && typeof rawTranscriptMeta.assistantMessageId === 'string' && rawTranscriptMeta.assistantMessageId;
       const metadata = persistedAssistantTranscriptMetadata(rawTranscriptMeta);
-      if (rawTranscriptMeta && typeof rawTranscriptMeta === 'object') delete rawTranscriptMeta.assistantAt;
+      if (live) {
+        // One-shot: the next reply gets its own time and stable id.
+        delete rawTranscriptMeta.assistantAt;
+        delete rawTranscriptMeta.assistantMessageId;
+        rawTranscriptMeta.persistedAssistant = rowKnowsId ? null : { messageId: metadata.messageId, at: metadata.at };
+      }
       return metadata;
     },
   };
@@ -138,7 +148,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
     // queued send always lands AFTER the in-flight prompt here, ordering is
     // preserved and the spawn/connecting startup race disappears.
     for (;;) {
-      const input = queue.nextTurn({ prompt, context, explicitPrefetch });
+      // `skillSelection` (askOpts) is the trusted selection input of the
+      // caller's own prompt only; drained follow-up turns never inherit it.
+      const input = queue.nextTurn({ prompt, context, explicitPrefetch, skillSelection: askOpts.skillSelection });
       if (!input) {
         void takeoverHydration.then((count) => {
           if (count <= 0) return;

package/src/runtime/agent/orchestrator/session/manager/ask-turn-auto-effort.mjs

@@ -8,7 +8,12 @@
 // model declares effort levels (the effort is sent with each request).
 import { readSection } from '../../../../shared/config.mjs';
 import { autoEffortModel, turnEffortConfigurationMode } from '../../providers/effort-configuration.mjs';
-import { autoEffortBase, normalizeAutoEffortMode, resolveAutoEffort } from '../../providers/auto-effort.mjs';
+import {
+  autoEffortApplicable,
+  autoEffortBase,
+  normalizeAutoEffortMode,
+  resolveAutoEffort,
+} from '../../providers/auto-effort.mjs';
 import { builtinFeatureActive } from '../../runtime-core/builtin-features.mjs';
 import { effortOptionsFor } from '../../runtime-core/effort.mjs';
 import { effortJudgeSupportsSteps, judgeTurn, recordEffortDecision } from '../../../../effort-judge/judge-client.mjs';
@@ -70,18 +75,14 @@ export async function resolveTurnAutoEffort({ sessionId, session, provider, inpu
   // Agent sessions are judged like any other: their spawn brief and later Lead
   // `send` messages arrive as plain prompts.
   if (mode === 'off' || input?.promptSource) return null;
+  // The session's route turned Auto effort off: its chosen effort stands.
+  if (session?.autoEffort === false) return null;
   const request = promptContentText(input?.prompt).trim();
   // Skill bodies and runtime blocks arrive as tagged text, not as a request.
   if (!request || request.startsWith('<')) return null;
   if (!turnEffortConfigurationMode(session, provider)) return null;
   const chosen = String(session.effort || '').toLowerCase();
   const base = autoEffortBase(chosen);
-  // The previous user request shows the work a short follow-up continues.
-  const judged = await judgeTurn({
-    request,
-    prev: lastText(session.messages, 'assistant'),
-    prevRequest: lastText(session.messages, 'user'),
-  });
   const record = {
     at: new Date().toISOString(),
     sessionId,
@@ -92,15 +93,24 @@ export async function resolveTurnAutoEffort({ sessionId, session, provider, inpu
     base,
     requestChars: request.length,
   };
+  const options = effortOptionsFor(session.provider, autoEffortModel(session.provider, provider, session.model));
+  // No judged outcome can apply when the base is off the model's ladder, so
+  // the judge is not asked (in observe mode too: nothing would be logged).
+  if (!autoEffortApplicable({ base, options })) {
+    recordEffortDecision({ ...record, skipped: 'default-outside-auto-range' });
+    return null;
+  }
+  // The previous user request shows the work a short follow-up continues.
+  const judged = await judgeTurn({
+    request,
+    prev: lastText(session.messages, 'assistant'),
+    prevRequest: lastText(session.messages, 'user'),
+  });
   if (!judged.probs) {
     recordEffortDecision({ ...record, skipped: judged.skipped });
     return null;
   }
-  const resolved = resolveAutoEffort({
-    base,
-    options: effortOptionsFor(session.provider, autoEffortModel(session.provider, provider, session.model)),
-    probs: judged.probs,
-  });
+  const resolved = resolveAutoEffort({ base, options, probs: judged.probs });
   recordEffortDecision({
     ...record,
     ...(resolved || { skipped: 'default-outside-auto-range' }),

package/src/runtime/agent/orchestrator/session/manager/ask-turn-execute.mjs

@@ -5,7 +5,7 @@
 // (runAskAgentLoop). Provider-not-available and trim failures throw here so
 // the caller marks the session errored instead of leaving stage='connecting'.
 import { getProvider } from '../../providers/registry.mjs';
-import { prepareExplicitSkills } from '../explicit-skills.mjs';
+import { notifySkillsApplied, prepareExplicitSkills, recordAppliedSkills } from '../explicit-skills.mjs';
 import { prepareTurnEffortConfiguration } from '../../providers/effort-configuration.mjs';
 import { resolveTurnAutoEffort, turnStepAutoEffort } from './ask-turn-auto-effort.mjs';
 import { saveSessionAsync } from '../store.mjs';
@@ -151,9 +151,16 @@ export async function runAskAgentLoop({
   }
   try {
     if (!input.promptSource) {
-      await prepareExplicitSkills(input.prompt, outgoing, session, { cwd: effectiveCwd, signal: turnSignal });
+      const applied = await prepareExplicitSkills(input.prompt, outgoing, session, {
+        cwd: effectiveCwd,
+        signal: turnSignal,
+        selection: input.skillSelection,
+      });
+      // The user turn message sits right after the history it was built on.
+      const userMessage = recordAppliedSkills(outgoing, outgoing[prepared.beforeCount - 1], applied);
       session.messages = filterModelVisibleSessionMessages(outgoing);
       checkpoint.schedule(true);
+      notifySkillsApplied(askOpts?.onSkillsApplied, applied, userMessage);
     }
     return await _api_call_with_interrupt(sessionId, (signal) =>
       agentLoop(

package/src/runtime/agent/orchestrator/session/manager/ask-turn-loop-options.mjs

@@ -13,7 +13,9 @@ const optionalFn = (value) => (typeof value === 'function' ? value : undefined);
 const relay = (fn, ...args) => {
   try {
     fn?.(...args);
-  } catch {}
+  } catch {
+    /* a host callback must never break the turn */
+  }
 };
 
 /**
@@ -70,10 +72,10 @@ export function buildAgentLoopOptions({
       checkpoint.schedule();
       if (typeof askOpts?.onReasoningDelta === 'function') askOpts.onReasoningDelta(chunk);
     },
-    onAssistantText: (text) => {
+    onAssistantText: (text, detail) => {
       interruption.recordAssistantText(text);
       checkpoint.schedule(true);
-      if (typeof askOpts?.onAssistantText === 'function') askOpts.onAssistantText(text);
+      if (typeof askOpts?.onAssistantText === 'function') askOpts.onAssistantText(text, detail);
     },
     takeAssistantTranscriptMetadata,
     // Send-opt only. Never copy onto `session` — a transient
@@ -150,6 +152,10 @@ export function buildAgentLoopOptions({
       checkpoint.schedule(true);
       relay(askOpts?.onSteerMessage, text, detail);
     },
+    onSkillsApplied: (names, detail) => {
+      checkpoint.schedule(true);
+      relay(askOpts?.onSkillsApplied, names, detail);
+    },
     notifyFn: optionalFn(askOpts?.notifyFn),
     // Same projection compaction uses, so a session presents one identity on
     // every request it makes.

package/src/runtime/agent/orchestrator/session/manager/ask-turn-settle.mjs

@@ -22,11 +22,13 @@ import { recordProviderContextBaseline } from '../loop/compact-policy.mjs';
 import { throwIfAborted } from '../../../../shared/abort-race.mjs';
 import { appendAssistantTurnMessage, persistProviderState, recordAskUsage } from './ask-turn-commit.mjs';
 
-function attachAssistantTranscriptCompletion(messages, completion, turnStartedAt = 0) {
+export function attachAssistantTranscriptCompletion(messages, completion, turnStartedAt = 0) {
   if (!Array.isArray(messages) || !completion || typeof completion !== 'object') return false;
   const elapsedMs = Math.max(0, Number(completion.elapsedMs || 0));
   const status = typeof completion.status === 'string' && completion.status ? completion.status : 'done';
   const verb = typeof completion.verb === 'string' && completion.verb ? completion.verb : 'Thought';
+  const checkpointId =
+    typeof completion.checkpointId === 'string' && completion.checkpointId ? completion.checkpointId : '';
   let turnStart = -1;
   const expectedAt = Number(turnStartedAt || 0);
   if (expectedAt > 0) {
@@ -60,7 +62,7 @@ function attachAssistantTranscriptCompletion(messages, completion, turnStartedAt
         ...meta,
         transcript: {
           ...transcript,
-          completion: { status, verb, elapsedMs },
+          completion: { status, verb, elapsedMs, ...(checkpointId ? { checkpointId } : {}) },
         },
       },
     };
@@ -145,6 +147,7 @@ export function publishAskTurn({ sessionId, opened, terminalResultPreview, askOp
         status: 'done',
         verb: rawTranscriptMeta?.completionVerb,
         elapsedMs: Date.now() - turnStartedAt,
+        checkpointId: rawTranscriptMeta?.checkpointId,
       },
       turnStartedAt
     );

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -15,6 +15,7 @@ import {
 } from '../context-utils.mjs';
 import { previewFreshContextCompaction, runFreshContextCompact } from '../loop/fresh-context.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
+import { writeStderrBestEffort } from '../../../../shared/best-effort-stderr.mjs';
 import { traceAgentCompact, messagePrefixHash } from '../../agent-trace.mjs';
 import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
 import { pruneOffloadSession } from '../tool-result-offload.mjs';
@@ -33,6 +34,7 @@ import {
   shouldCompactForRequestMedia,
 } from '../loop/compact-policy.mjs';
 import { snapshotProviderRequestTools } from '../../runtime-core/tool-catalog.mjs';
+import { scheduleCompactionArchive, stampCompactionMessageIds } from '../compaction-archive-capture.mjs';
 
 // 'compacting' is a transient in-flight stage written just before Compact
 // runs. If the process crashes or only partially
@@ -126,7 +128,7 @@ function handoffSummaryTimeoutMs(session, messageTokens) {
  * mutated and nothing is persisted — so a caller may compact a COPY of a
  * conversation. Session inheritance relies on exactly that: an oversized
  * transcript is compacted for the heir while the session that owns it keeps
- * every message (user: 자동으로 컴팩트하고 승계).
+ * every message.
  */
 export async function runHandoffCompaction({
   session,
@@ -190,9 +192,8 @@ async function sessionCompactionPlan(session, opts) {
   }
   // Reserve must mirror loop.mjs (buildCompactPolicy): request reserve (tool
   // schema) PLUS the configured reserve (session.compaction.reservedTokens or
-  // MIXDOG_AGENT_COMPACT_RESERVED_TOKENS env). The old request-only value left
-  // the manual / auto-clear compact budget without the configured headroom the
-  // loop path reserves, so a compacted transcript could overflow on next send.
+  // MIXDOG_AGENT_COMPACT_RESERVED_TOKENS env). Without the configured headroom
+  // the loop path reserves, a compacted transcript could overflow on next send.
   // A cold (just loaded) transcript is metered in slices first; the plan
   // numbers below then read the per-message memos.
   await primeContextEstimates(messages, session);
@@ -202,6 +203,7 @@ async function sessionCompactionPlan(session, opts) {
     resolvedSessionId,
     mode,
     force,
+    archive: opts.archive !== false,
     messages,
     boundary,
     alignedPolicy,
@@ -292,8 +294,8 @@ function compactionRecord(plan, { stage, after, now, reserve, outcome }) {
 }
 
 // compact_meta parity with the loop's pre-send pass: the out-of-loop
-// (post-turn/manual) compaction — and its failure — used to be invisible to
-// trace analytics.
+// (post-turn/manual) compaction — and its failure — is visible to trace
+// analytics.
 function traceSessionCompaction(plan, compactStartedAt, { counts, failure }) {
   const { session, mode } = plan;
   traceAgentCompact({
@@ -342,13 +344,9 @@ async function runSessionHandoff(plan, opts) {
   } catch (err) {
     run.freshContextError = err;
     run.compactError = err;
-    try {
-      process.stderr.write(
-        `[session] fresh-context ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`
-      );
-    } catch {
-      /* best-effort */
-    }
+    writeStderrBestEffort(
+      `[session] fresh-context ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`
+    );
   }
   if (!run.compacted && !run.compactError) {
     run.compactError = new Error('fresh-context compact produced no messages');
@@ -515,8 +513,8 @@ function compactionOutcome(session, freshContextResult, changed, now) {
 }
 
 // Observability parity with the loop's pre-send pass: record the
-// out-of-loop mutation as compact_meta (observed live: a 403k→10k post-turn
-// compact traced as intentional_transition: null with no compact_meta).
+// out-of-loop mutation as compact_meta, so a large post-turn compact is not
+// traced as intentional_transition: null.
 function traceCommittedCompaction(plan, compactStartedAt, { messages, compacted, beforeBytes, afterBytes, changed }) {
   let beforePrefixHash = null;
   try {
@@ -645,6 +643,19 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
     },
     outcome: compactionOutcome(session, freshContextResult, changed, now),
   });
+  // Display-only: the dropped conversation stays readable above the divider.
+  // Only the selection and the segment number happen here; the projection and
+  // the write run later, off this commit.
+  const archived =
+    changed && plan.archive
+      ? scheduleCompactionArchive({
+          session,
+          sessionId: resolvedSessionId,
+          before: messages,
+          after: transcript,
+          at: now,
+        })
+      : null;
   if (changed) {
     invalidateProviderContextBaseline(session);
     if (postCompactPolicy) {
@@ -678,6 +689,10 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
       freshContextError: null,
       handoffSource: freshContextResult?.handoffSource || 'session-local',
       usage: freshContextResult?.usage || null,
+      // Messages that left the model context (0 for a rewrite-only pass):
+      // surfaces archive only those rows.
+      droppedMessages: archived?.dropped ?? 0,
+      droppedIdentities: archived?.identities ?? null,
     }
   );
 }
@@ -692,7 +707,8 @@ export async function runSessionCompaction(session, opts = {}) {
     });
   }
   plan.requireReduction =
-    (plan.mode === 'auto' || opts.requireReduction === true) && !shouldCompactForRequestMedia(plan.messages, session.provider);
+    (plan.mode === 'auto' || opts.requireReduction === true) &&
+    !shouldCompactForRequestMedia(plan.messages, session.provider);
   const skipped = () =>
     compactionResult(plan, { changed: false, skipped: true, reason: 'no_token_reduction' }, unchangedAfter(plan), {
       freshContext: false,
@@ -713,6 +729,11 @@ export async function runSessionCompaction(session, opts = {}) {
     }).reducesTokens
   )
     return skipped();
+  // Every message enters the compaction with a stable id (legacy ones are
+  // stamped now and persisted): the result's rewrites carry it, so what was
+  // dropped is exactly the ids the result no longer holds. The snapshot is a
+  // prefix of the live transcript holding the same message objects.
+  stampCompactionMessageIds(plan.messages, plan.resolvedSessionId);
   const compactStartedAt = Date.now();
   try {
     await opts.onStageChange?.('compacting');

package/src/runtime/agent/orchestrator/session/manager/context-meta.mjs

@@ -117,8 +117,12 @@ export function resolveSessionContextMeta(provider, model, seed = {}, { wholeWin
   // (a session older than selectedContextWindow, a route saved before the
   // catalog warmed) is still the user's choice and keeps the served window.
   const recordsSelection = wholeWindow || boundedPercent(seed.contextPercent) !== null;
+  // An exact token selection without its resolved window still names it,
+  // bounded by what the model serves.
+  const selectedTokens = positiveInt(seed.contextTokens);
   const requestedContextWindow =
     positiveInt(seed.selectedContextWindow) ||
+    (selectedTokens ? Math.min(selectedTokens, servedContextWindow) : 0) ||
     (recordsSelection
       ? servedContextWindow
       : contextWindowRange({ provider: providerNameOf(provider), contextWindow: servedContextWindow }).defaultWindow);

package/src/runtime/agent/orchestrator/session/manager/pending-message-entry.mjs

@@ -158,6 +158,14 @@ export function lateDeliveryText(text, entry, now = Date.now()) {
   return `[late delivery: queued ${age} ago, before the current session owner started]\n${value}`;
 }
 
+// A non-completion entry may be queued explicitly as a task notification (a
+// runtime/channel notice, never the user typing): the mode survives
+// normalization and the durable spool so the drain stores it as one and it
+// never drives explicit skill selection.
+function explicitModeField(entry) {
+  return entry?.mode === PENDING_MODE_TASK_NOTIFICATION ? { mode: PENDING_MODE_TASK_NOTIFICATION } : {};
+}
+
 export function normalizePendingMessageEntry(entry) {
   if (typeof entry === 'string') {
     const text = entry.trim();
@@ -173,7 +181,10 @@ export function normalizePendingMessageEntry(entry) {
     id: pendingMessageId(entry),
     enqueuedAt: Number(entry.enqueuedAt) || Date.now(),
   };
-  const entryOptions = entry.options && typeof entry.options === 'object' ? { options: entry.options } : {};
+  const entryOptions = {
+    ...(entry.options && typeof entry.options === 'object' ? { options: entry.options } : {}),
+    ...explicitModeField(entry),
+  };
   const marker =
     entry.notificationKind === COMPLETION_NOTIFICATION_KIND
       ? {
@@ -259,26 +270,28 @@ function normalizePersistedEntryBase(entry) {
         }
       : null;
   }
+  const mode = explicitModeField(entry);
   if (typeof entry.message === 'string') {
     const message = entry.message.trim();
-    return message ? { id, message, enqueuedAt } : null;
+    return message ? { id, message, ...mode, enqueuedAt } : null;
   }
   if (Object.hasOwn(entry, 'content')) {
     const normalized = normalizePendingMessageEntry(entry);
     if (!normalized) return null;
     if (typeof normalized.content === 'string' && !normalized.options) {
-      return { id, message: normalized.text || normalized.content, enqueuedAt };
+      return { id, message: normalized.text || normalized.content, ...mode, enqueuedAt };
     }
     return {
       id,
       content: normalized.content,
       text: normalized.text,
       ...(normalized.options ? { options: normalized.options } : {}),
+      ...mode,
       enqueuedAt,
     };
   }
   const text = pendingMessageText(entry);
-  return text ? { id, message: text, enqueuedAt } : null;
+  return text ? { id, message: text, ...mode, enqueuedAt } : null;
 }
 
 export function modelVisiblePendingMessages(messages) {

package/src/runtime/agent/orchestrator/session/manager/prompt-utils.mjs

@@ -185,6 +185,96 @@ export function refreshSessionBp3Environment(session, cwd) {
   return true;
 }
 
+const CORE_MEMORY_HEADING = '# Core Memory\n';
+const INSTRUCTION_FILES_HEADING = '# Instruction Files';
+
+function trimmedSlice(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+// Where a heading-led slice starts in a BP3 join: `cut` ends the text before
+// it (separator included), `start` is the slice's first character.
+function bp3SliceAt(text, heading) {
+  if (text.startsWith(heading)) return { cut: 0, start: 0 };
+  const at = text.indexOf(`${BP3_PART_SEPARATOR}${heading}`);
+  return at < 0 ? null : { cut: at, start: at + BP3_PART_SEPARATOR.length };
+}
+
+/**
+ * Replace the workspace-scoped tail of a BP3 core (composeSystemPrompt order:
+ * …, `# Core Memory`, `# Instruction Files`). The instruction-files slice is
+ * always last and may itself contain separators, so it is cut by position;
+ * the core-memory slice is one separator-free part. `undefined` keeps a slice,
+ * an empty string drops it.
+ * @param {string} core
+ * @param {{ coreMemoryContext?: string, instructionFilesContext?: string }} slices
+ */
+export function replaceWorkspaceCoreSlices(core, { coreMemoryContext, instructionFilesContext } = {}) {
+  let head = String(core || '');
+  let instructionFiles = '';
+  const instructionAt = bp3SliceAt(head, INSTRUCTION_FILES_HEADING);
+  if (instructionAt) {
+    instructionFiles = head.slice(instructionAt.start);
+    head = head.slice(0, instructionAt.cut);
+  }
+  let parts = head ? head.split(BP3_PART_SEPARATOR) : [];
+  if (coreMemoryContext !== undefined) {
+    parts = parts.filter((part) => !part.startsWith(CORE_MEMORY_HEADING));
+    const memory = trimmedSlice(coreMemoryContext);
+    if (memory) parts.push(`${CORE_MEMORY_HEADING}${memory}`);
+  }
+  if (instructionFilesContext !== undefined) instructionFiles = trimmedSlice(instructionFilesContext);
+  return [...parts, instructionFiles].filter((part) => part && part.trim()).join(BP3_PART_SEPARATOR);
+}
+
+/**
+ * Replace the shell/project facts that lead the persisted environment tail
+ * (`- Cwd …`, shell tools, git state, cwd listing); the trailing response
+ * language block is kept. `undefined` keeps the facts.
+ */
+export function replaceWorkspaceEnvironment(environmentTail, environmentContext) {
+  if (environmentContext === undefined) return environmentTail;
+  const parts = typeof environmentTail === 'string' && environmentTail ? environmentTail.split(BP3_PART_SEPARATOR) : [];
+  const facts = trimmedSlice(environmentContext);
+  if (parts[0]?.startsWith('- ')) parts[0] = facts;
+  else parts.unshift(facts);
+  return parts.filter((part) => part && part.trim()).join(BP3_PART_SEPARATOR);
+}
+
+/**
+ * Re-root an existing session's prompt at a new workspace without touching
+ * the conversation: environment facts, project memory and instruction files
+ * are replaced in place (never appended), then the `# Session` block is
+ * rebuilt for `cwd`. Messages are replaced, not mutated, so delta saves write
+ * a full snapshot.
+ * @param {object} session
+ * @param {{ cwd: string, environmentContext?: string, coreMemoryContext?: string, instructionFilesContext?: string }} context
+ * @returns {boolean}
+ */
+export function refreshSessionWorkspaceContext(
+  session,
+  { cwd, environmentContext, coreMemoryContext, instructionFilesContext } = {}
+) {
+  if (!session) return false;
+  if (typeof session.bp3EnvironmentContext === 'string') {
+    session.bp3EnvironmentContext = replaceWorkspaceEnvironment(session.bp3EnvironmentContext, environmentContext);
+  }
+  const slices = { coreMemoryContext, instructionFilesContext };
+  if (session.bp3EnvSplit === true) {
+    const target = bp3SystemMessage(session);
+    if (target && typeof target.content === 'string') {
+      const nextCore = replaceWorkspaceCoreSlices(target.content, slices);
+      replaceSystemMessageContent(session, target, nextCore);
+      session.bp3CoreContext = nextCore;
+    }
+  } else if (typeof session.bp3CoreContext === 'string') {
+    // Legacy combined layout: refreshSessionBp3Environment rebuilds the tier3
+    // block from the core plus the environment below.
+    session.bp3CoreContext = replaceWorkspaceCoreSlices(session.bp3CoreContext, slices);
+  }
+  return refreshSessionBp3Environment(session, cwd);
+}
+
 export function resetSessionBp3Environment(session) {
   if (session?.bp3EnvSplit === true) {
     const target = bpEnvSystemMessage(session);