mixdog 1.2.6 → 1.3.0

package/src/tui/session/notice-surface.mjs

@@ -31,12 +31,43 @@ export function createNoticeSurface({ getState, set, isDisposed, pushItem, repla
     return id;
   };
   const pushNotice = (text, tone = 'info', options = {}) => {
-    const value = polishNoticeText(text);
-    if (!value) return null;
+    // A routine result is a finished sentence, never a raw error to polish;
+    // a group-room row is someone's words, kept verbatim (a pass has none).
+    const value =
+      options.routine || options.room || options.heldRequest ? String(text ?? '').trim() : polishNoticeText(text);
+    if (!value && !options.room) return null;
     const forceTranscript = options.transcript === true;
     if (!forceTranscript) return pushToast(value, tone, options.ttlMs, options);
-    const id = nextId();
-    pushItem({ kind: 'notice', id, text: value, tone });
+    const userRow = options.room?.kind === 'user';
+    // A room user row keeps its message id (the sender's submission id), as a
+    // turn's own prompt row keeps its submission id.
+    const id = (userRow && options.messageId) || nextId();
+    // One row per messageId: a routine's live-only run row (running, delivery
+    // failed) gives way to the row that follows it (routine-result.mjs).
+    if (options.messageId) {
+      const current = getState().items;
+      const items = current.filter((it) => !(it?.kind === 'notice' && it?.messageId === options.messageId));
+      if (items.length !== current.length) set({ items: replaceItems(items, { preserveStreamingTail: true }) });
+    }
+    pushItem({
+      // A group-room row (agent-room.mjs): the user's own words are their
+      // bubble; every member row is a notice the app renders from `room`.
+      kind: userRow ? 'user' : 'notice',
+      id,
+      text: value,
+      ...(userRow ? {} : { tone }),
+      // A schedule result posted into a home thread (routine-result.mjs).
+      ...(options.routine ? { routine: options.routine } : {}),
+      ...(options.room ? { room: options.room } : {}),
+      // A room user row's files, in the fields a prompt row draws them from.
+      ...(userRow && Array.isArray(options.attachments) && options.attachments.length
+        ? { attachments: options.attachments }
+        : {}),
+      ...(userRow && Array.isArray(options.images) && options.images.length ? { images: options.images } : {}),
+      // A held request of an unattended run (human-gate/held-message.mjs).
+      ...(options.heldRequest ? { heldRequest: options.heldRequest } : {}),
+      ...(options.messageId ? { messageId: options.messageId } : {}),
+    });
     return id;
   };
   // Remove a transcript notice previously created via pushNotice(...,

package/src/tui/session/queue-helpers.mjs

@@ -5,6 +5,7 @@
  */
 import { agentJobResultText, parseAgentJob, parseSyntheticAgentMessage } from './agent-envelope.mjs';
 import { attachmentTextForPart, isAttachmentReference } from '../../runtime/attachments/store.mjs';
+import { recognisedSlashToken } from '../app/slash-commands.mjs';
 
 const QUEUE_PRIORITY = { now: 0, next: 1, later: 2 };
 
@@ -52,7 +53,7 @@ export function isQueuedEntryVisible(entry) {
 export function isSlashQueuedEntry(entry) {
   if (entry?.skipSlashCommands) return false;
   const text = promptContentText(entry?.content ?? entry?.text ?? '');
-  return text.trim().startsWith('/');
+  return recognisedSlashToken(text) !== null;
 }
 
 function firstQueueLine(text) {

package/src/tui/session/session-api/extensions.mjs

@@ -121,6 +121,10 @@ export function createSessionExtensionsApi(bag) {
       (input) => runtime.saveSkill?.(input),
       (result, input) => [`skill saved: ${result?.skill?.name || input?.name || 'skill'}`]
     ),
+    removeSkill: lockedChange(
+      (input) => runtime.removeSkill?.(input),
+      (result, input) => [`skill removed: ${result?.skill?.name || input?.name || 'skill'}`]
+    ),
     reloadSkills: lockedChange(
       () => runtime.reloadSkills?.(),
       (status) => [`skills reload: ${status?.count || 0} available`]

package/src/tui/session/session-api/intake/submission.mjs

@@ -14,6 +14,11 @@ export function createSubmissionIntake(bag) {
       text,
       queueOptions: {
         ...options,
+        // A kickoff (a new agent's greeting turn) reaches the model only: no
+        // user bubble, no queue row, never restored into the composer.
+        ...(options.kickoff === true
+          ? { isMeta: true, suppressDisplay: true, skipSlashCommands: true, restorable: false }
+          : {}),
         // Always mint a submission id so daemon retries / dual-path intake
         // can dedupe instead of booking the same prompt twice.
         id: String(options.id || '').trim() || nextId(),

package/src/tui/session/session-api/integrations.mjs

@@ -191,6 +191,14 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       (name) => runtime.runScheduleNow(name),
       (_result, name) => `schedule ran: ${name}`
     ),
+    runWebhookNow: announced(
+      (name) => runtime.runWebhookNow(name),
+      (_result, name) => `webhook ran: ${name}`
+    ),
+    retryRoutineDelivery: announced(
+      (kind, name) => runtime.retryRoutineDelivery(kind, name),
+      (_result, kind, name) => `${kind} result delivered: ${name}`
+    ),
     saveWebhook: announced(
       (entry) => runtime.saveWebhook(entry),
       (result) => `webhook saved: ${result.name}`

package/src/tui/session/session-api/lifecycle/session-reset.mjs

@@ -78,18 +78,28 @@ export function createSessionResetActions(bag) {
   };
 
   return {
-    clear: () =>
+    // `archiveAs`: the id the outgoing transcript is kept under (an agent
+    // home's fresh start); the clear fails rather than wipe without it.
+    // `rebuildPrompt` / `fork: false`: an agent chat's reset (session-ops clear).
+    clear: (options = {}) =>
       withResetLock(async () => {
+        const archiveAs = typeof options?.archiveAs === 'string' ? options.archiveAs : '';
+        const reset = {
+          ...(options?.rebuildPrompt === true ? { rebuildPrompt: true } : {}),
+          ...(options?.fork === false ? { fork: false } : {}),
+        };
         const clearedId = getState().sessionId;
         // A cleared session has no failed turn left to resume.
         bag.supersedeQuotaResume?.(clearedId);
         const rollbackSnapshot = beginTuiReset();
         set(blankSessionPatch());
         try {
-          await runtime.clear({ recoverAgent: true });
+          const result = await runtime.clear({ recoverAgent: true, ...(archiveAs ? { archiveAs } : {}), ...reset });
+          if (result === false && (archiveAs || reset.rebuildPrompt))
+            throw new Error('The conversation could not be cleared.');
           commitEmptySession(rollbackSnapshot);
           flags.lastUserActivityAt = Date.now();
-          return true;
+          return reset.rebuildPrompt ? result : true;
         } catch (error) {
           restoreTuiAfterFailedSessionReset(rollbackSnapshot);
           throw error;

package/src/tui/session/session-api/lifecycle.mjs

@@ -9,6 +9,17 @@ import { createInheritanceActions } from './lifecycle/inheritance.mjs';
 import { createResumeAction } from './lifecycle/resume.mjs';
 import { createDisposeAction } from './lifecycle/dispose.mjs';
 import { publishModelSwitch } from './routes.mjs';
+import { resolveHeldRequest } from '../../../runtime/shared/held-request-host.mjs';
+
+/** The human-response fields of a decision (never a value), or null. */
+function humanDecisionFields(decision) {
+  if (!decision || typeof decision !== 'object') return null;
+  const fields = {};
+  for (const key of ['response', 'editedArgs', 'remember', 'scope']) {
+    if (decision[key] !== undefined) fields[key] = decision[key];
+  }
+  return Object.keys(fields).length ? fields : null;
+}
 
 export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFlows }) {
   const { runtime, pushNotice, removeNotice, setProgressHint, finishToolApproval } = bag;
@@ -52,14 +63,19 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
   return {
     isSessionTerminal: () => bag.flags?.admission === 'terminal' || runtime.isSessionTerminal?.() === true,
     resolveToolApproval: (id, decision = {}) => {
+      // A held request of an unattended run is answered from its owner's home
+      // thread, wherever the run itself lives (session-runtime/held-requests.mjs).
+      if (resolveHeldRequest(id, decision)) return true;
       const approved = decision === true || decision?.approved === true;
+      const extra = humanDecisionFields(decision);
       return finishToolApproval(
         id,
         approved,
         decision?.reason || (approved ? 'approved by user' : 'denied by user'),
         typeof decision?.device === 'string' ? decision.device : '',
         decision?.answers,
-        typeof decision?.reply === 'string' ? decision.reply : undefined
+        typeof decision?.reply === 'string' ? decision.reply : undefined,
+        ...(extra ? [extra] : [])
       );
     },
     pushNotice,

package/src/tui/session/session-api/routes.mjs

@@ -3,7 +3,10 @@
  * the serialized optimistic setRoute, web-search route, workflows, agent
  * definitions, output style and orchestration mode.
  */
-import { modelSwitchItem } from '../../../runtime/agent/orchestrator/session/transcript-restore/restore.mjs';
+import {
+  modelSwitchItem,
+  workflowSwitchItem,
+} from '../../../runtime/agent/orchestrator/session/transcript-restore/restore.mjs';
 import { selectedModel } from '../../../session-runtime/model-route/model-switch-target.mjs';
 import { createApiHelpers } from './shared.mjs';
 
@@ -272,8 +275,48 @@ export function createSessionRouteApi(bag) {
     createWorkflow: async (payload) => runtime.createWorkflow?.(payload) ?? null,
     deleteWorkflow: async (workflowId) => runtime.deleteWorkflow?.(workflowId) ?? null,
     getAgentDefinition: (agentId) => runtime.getAgentDefinition?.(agentId) ?? null,
+    getAgentAvatarImage: (agentId) => runtime.getAgentAvatarImage?.(agentId) ?? null,
+    getAgentConnectors: (agentId) => runtime.getAgentConnectors?.(agentId) ?? [],
+    listConnectors: () => runtime.listConnectors?.() ?? [],
+    listConnectorTools: (connectorId) => runtime.listConnectorTools?.(connectorId) ?? [],
+    setAgentConnectors: async (agentId, connectors) => runtime.setAgentConnectors?.(agentId, connectors) ?? null,
+    setAgentConnectorEnabled: async (agentId, connectorId, enabled) =>
+      runtime.setAgentConnectorEnabled?.(agentId, connectorId, enabled) ?? [],
+    getProjectConnectors: (projectPath) => runtime.getProjectConnectors?.(projectPath) ?? [],
+    setProjectConnectorEnabled: async (projectPath, connectorId, enabled) =>
+      runtime.setProjectConnectorEnabled?.(projectPath, connectorId, enabled) ?? [],
+    setAgentConnectorToolPermission: async (agentId, connectorId, toolName, permission) =>
+      runtime.setAgentConnectorToolPermission?.(agentId, connectorId, toolName, permission) ?? null,
+    // Per-agent action-kind permissions (ask / allow / block) for the profile.
+    getAgentPermissions: async (agentId) =>
+      (await import('../../../runtime/agent/orchestrator/session/human-gate/store.mjs')).agentPermissions(agentId),
+    setAgentPermission: async (agentId, action, mode) =>
+      (await import('../../../runtime/agent/orchestrator/session/human-gate/store.mjs')).setAgentPermission(
+        agentId,
+        action,
+        mode
+      ),
+    getLeadPersona: () => runtime.getLeadPersona?.() ?? '',
+    saveLeadPersona: async (text) => runtime.saveLeadPersona?.(text) ?? '',
+    getLeadAgentBody: () => runtime.getLeadAgentBody?.() ?? '',
+    saveLeadAgentBody: async (text) => runtime.saveLeadAgentBody?.(text) ?? '',
+    getLeadStatus: () => runtime.getLeadStatus?.() ?? { created: null, name: '', avatar: null },
+    saveLeadIdentity: async (payload) => runtime.saveLeadIdentity?.(payload) ?? null,
+    setLeadCreated: async (created, description) => runtime.setLeadCreated?.(created, description) ?? null,
     saveAgentDefinition: async (payload) => runtime.saveAgentDefinition?.(payload) ?? null,
     deleteAgentDefinition: async (agentId) => runtime.deleteAgentDefinition?.(agentId) ?? null,
+    agentDefinitionPresence: (agentIds) => runtime.agentDefinitionPresence?.(agentIds) ?? null,
+    restoreAgentDefinition: async (agentId) => runtime.restoreAgentDefinition?.(agentId) ?? null,
+    purgeAgentDefinition: async (agentId) => runtime.purgeAgentDefinition?.(agentId) ?? null,
+    archivedAgentIdentities: (agentIds) => runtime.archivedAgentIdentities?.(agentIds) ?? null,
+    // Group-room rows posted by the desktop host into a room's log session.
+    appendRoomRows: async (sessionId, rows) =>
+      (await import('../../../session-runtime/agent-room-delivery.mjs')).appendRoomRows(sessionId, rows),
+    // One group-room supervisor step on the Maintainer route.
+    decideRoomTurn: async (input) =>
+      (await import('../../../runtime/agent/orchestrator/agent-runtime/room-supervisor-completion.mjs')).decideRoomTurn(
+        input
+      ),
     getOutputStyle: () => {
       return runtime.getOutputStyle?.() || runtime.listOutputStyles?.() || null;
     },
@@ -291,8 +334,10 @@ export function createSessionRouteApi(bag) {
       deferStatsRefresh();
       return result;
     }),
-    setWorkflow: withCommandLock(async (workflowId) => {
-      const result = await runtime.setWorkflow?.(workflowId);
+    setWorkflow: withCommandLock(async (workflowId, options) => {
+      const result = await runtime.setWorkflow?.(workflowId, options);
+      // A switch of this conversation leaves a divider (restored from message meta).
+      if (result?.workflowSwitch) bag.pushItem(workflowSwitchItem(bag.nextId(), result.workflowSwitch));
       publishRoute();
       return result;
     }),

package/src/tui/session/session-flow/drain.mjs

@@ -52,6 +52,13 @@ function renderBatchItems(batch, pushUserOrSyntheticItem) {
       }
       continue;
     }
+    // A routine fire paints as the routine's marker row, not a user bubble.
+    if (entry.mode === 'routine') {
+      pushUserOrSyntheticItem(entry.text, entry.id, 'routine', {
+        routineTrigger: entry.transcriptMeta?.routineTrigger,
+      });
+      continue;
+    }
     const sender = String(entry.transcriptMeta?.sender || '')
       .trim()
       .toLowerCase();
@@ -106,6 +113,10 @@ export function turnOptionsForBatch(batch, steering) {
       Array.isArray(entry?.resumeCompletionKeys) ? entry.resumeCompletionKeys : []
     ),
     transcriptMeta: batch[0]?.transcriptMeta || null,
+    // Only a routine turn names its selection text (never its payload).
+    ...(batch[0]?.mode === 'routine' && typeof batch[0].skillSelection === 'string'
+      ? { skillSelection: batch[0].skillSelection }
+      : {}),
     context:
       batch
         .map((entry) => String(entry.context || '').trim())
@@ -191,9 +202,7 @@ export function createDrainLoop(
     clearBlockedDrainRetry();
     if (entries.length === 0) return;
     queue.removeQueuedEntries(entries);
-    const mirrored = entries.filter(
-      (entry) => steering.shouldMirrorSteeringEntry(entry) && !entry.steeringPersistRestored
-    );
+    const mirrored = entries.filter((entry) => steering.shouldMirrorSteeringEntry(entry) && entry.steeringPersistId);
     if (mirrored.length > 0) {
       void Promise.resolve(dropTuiSteeringPersist(steering.leadSessionId(), mirrored)).catch(() => {});
     }

package/src/tui/session/session-flow/queue/entry-shape.mjs

@@ -43,8 +43,9 @@ export function makeQueueEntry(text, options = {}, nextId) {
       ? options.resumeCompletionKeys.filter((key) => key != null && String(key).trim())
       : [],
     steeringPersistId: options.steeringPersistId || null,
-    steeringPersistRestored: options.steeringPersistRestored === true,
     isMeta: options.isMeta === true,
+    // A routine turn's trusted skill-selection text (its instructions only).
+    skillSelection: typeof options.skillSelection === 'string' ? options.skillSelection : null,
     goalId: options.goalId || null,
     // Retry of a failed turn: the transcript and the session rewind the
     // failed turn's unanswered prompt before this entry runs.

package/src/tui/session/session-flow/queue/take-entries.mjs

@@ -43,7 +43,8 @@ export function createTakeEntriesOps({ pending, pendingNotificationKeys, removeQ
         batch.push(entry);
         pending.splice(i, 1);
         if (entry.mode === 'task-notification' && entry.key) pendingNotificationKeys.delete(entry.key);
-        if (entry.retryTurnId || batch.length >= limit) break;
+        // A routine fire is a turn of its own, never merged with another.
+        if (entry.retryTurnId || entry.mode === 'routine' || batch.length >= limit) break;
       } else {
         i += 1;
       }
@@ -73,7 +74,7 @@ export function createTakeEntriesOps({ pending, pendingNotificationKeys, removeQ
     // A reclaimed prompt goes back to the draft, so its durable steering
     // mirror goes with it; otherwise the next runtime restore re-queues a
     // prompt the user already took back.
-    const mirrored = queued.filter((entry) => entry.steeringPersistId && !entry.steeringPersistRestored);
+    const mirrored = queued.filter((entry) => entry.steeringPersistId);
     if (mirrored.length > 0) void dropTuiSteeringPersist(leadSessionId(), mirrored);
     const queuedText = queued
       .map((item) => item.text)

package/src/tui/session/session-flow/steering.mjs

@@ -12,10 +12,13 @@ import {
   callCommitCallbacks,
   STEERING_SUPPRESSED_DISPLAY,
 } from '../queue-helpers.mjs';
-import { dropTuiSteeringPersist, drainTuiSteeringPersist } from '../tui-steering-persist.mjs';
+import { dropTuiSteeringPersist, readTuiSteeringPersist } from '../tui-steering-persist.mjs';
 import { getBackgroundTask } from '../../../runtime/shared/background-tasks.mjs';
 
 const RESTORE_DEDUP_WINDOW = 80;
+// An older build's process-local item counter: a later process issues the
+// same ids again, so such an id proves nothing about delivery.
+const PROCESS_LOCAL_ITEM_ID = /^it_\d+$/;
 
 // Mid-chain drain converts queued prompt/task notification entries into
 // model-visible "queued_command" style steering only at provider continuation
@@ -65,8 +68,28 @@ function steeringMessageFromEntry(entry) {
   return String(content ?? '').trim().length > 0 ? { ...meta, text: displayText, content } : null;
 }
 
-// Recent user message bodies define "already delivered" for restore dedup;
-// substring (not equality) because steering delivery may wrap the raw text.
+// The submissions the transcript holds: a turn's prompt (`checkpointId`, plus
+// `submissionIds` for a merged batch) and a steered message's `submissionIds`.
+function deliveredSubmissionIds(session) {
+  const out = new Set();
+  for (const message of Array.isArray(session?.messages) ? session.messages : []) {
+    if (message?.role !== 'user') continue;
+    const meta = message.meta || {};
+    const transcript = meta.transcript || {};
+    for (const id of [
+      transcript.checkpointId,
+      ...(Array.isArray(transcript.submissionIds) ? transcript.submissionIds : []),
+      ...(Array.isArray(meta.submissionIds) ? meta.submissionIds : []),
+    ]) {
+      if (typeof id === 'string' && id) out.add(id);
+    }
+  }
+  return out;
+}
+
+// Rows of an older build carry no stable submission id; only their text can
+// tell them delivered: substring (not equality) because steering delivery may
+// wrap the raw text.
 function recentUserTexts(session, window) {
   const messages = Array.isArray(session?.messages) ? session.messages : [];
   const out = [];
@@ -107,7 +130,7 @@ export function createSteeringOps(bag, { queue, submissions }) {
   function commitSteeringQueueEntries(entries) {
     callCommitCallbacks(entries);
     const mirrored = (Array.isArray(entries) ? entries : []).filter(
-      (entry) => shouldMirrorSteeringEntry(entry) && !entry.steeringPersistRestored
+      (entry) => shouldMirrorSteeringEntry(entry) && entry.steeringPersistId
     );
     if (mirrored.length > 0) dropTuiSteeringPersist(leadSessionId(), mirrored);
   }
@@ -205,46 +228,57 @@ export function createSteeringOps(bag, { queue, submissions }) {
   async function restoreLeadSteeringFromDisk() {
     // A closed/closing conversation never gets queue work restored into it.
     if (!admissionOpen()) return;
-    const rows = await drainTuiSteeringPersist(leadSessionId());
+    const rows = await readTuiSteeringPersist(leadSessionId());
     if (!rows.length) return;
     const livePersistIds = new Set(pending.map((entry) => entry?.steeringPersistId).filter(Boolean));
-    // Crash-consumed dedup: a row whose text already landed in the session
-    // transcript was consumed before the restart — only its disk drop was
-    // lost (drop is an async fire-and-forget write). Re-queuing it silently
-    // re-injects a stale prompt into the next turn (user report: surprise
-    // self-injection after a process restart).
-    const delivered = recentUserTexts(runtime.session, RESTORE_DEDUP_WINDOW);
-    const alreadyDelivered = (text) => delivered.some((body) => body.includes(text));
+    // Crash-consumed dedup: a row whose submission already landed in the
+    // session transcript was consumed before the restart — only its disk drop
+    // was lost (drop is an async fire-and-forget write). Re-queuing it
+    // silently re-injects a stale prompt into the next turn (user report:
+    // surprise self-injection after a process restart). Identity, never text:
+    // the same words can be a new submission.
+    const delivered = deliveredSubmissionIds(runtime.session);
+    let legacyTexts = null;
+    const alreadyDelivered = (row, text) => {
+      if (row.submissionId && !PROCESS_LOCAL_ITEM_ID.test(row.submissionId)) return delivered.has(row.submissionId);
+      legacyTexts ??= recentUserTexts(runtime.session, RESTORE_DEDUP_WINDOW);
+      return legacyTexts.some((body) => body.includes(text));
+    };
     const restored = [];
-    let droppedDelivered = 0;
+    const consumed = [];
     for (const row of rows) {
       const text = String(row?.text || '').trim();
       if (!text) continue;
       // Live enqueue already holds this row (id assigned before the async
       // disk write). Replaying it is the classic double-booked queue.
       if (row.steeringPersistId && livePersistIds.has(row.steeringPersistId)) continue;
-      if (alreadyDelivered(text)) {
-        droppedDelivered += 1;
+      if (alreadyDelivered(row, text)) {
+        consumed.push(row);
         continue;
       }
-      const entry = queue.makeQueueEntry(row.text, {
-        id: row.submissionId || undefined,
-        submittedAt: row.submittedAt || undefined,
-        steeringPersistRestored: true,
-        steeringPersistId: row.steeringPersistId || undefined,
+      // The row keeps its executable content and attachment links; a row
+      // of an older build has only its text.
+      const { content, text: displayText, submissionId, submittedAt, ...options } = row;
+      const entry = queue.makeQueueEntry(content ?? displayText, {
+        ...options,
+        id: submissionId || undefined,
+        submittedAt: submittedAt || undefined,
+        displayText,
       });
       pending.push(entry);
-      if (row.submissionId) submissions.remember(row.submissionId);
-      if (entry.steeringPersistId) livePersistIds.add(entry.steeringPersistId);
+      if (submissionId) submissions.remember(submissionId);
+      livePersistIds.add(entry.steeringPersistId);
       if (isQueuedEntryVisible(entry)) restored.push(entry);
     }
     if (restored.length > 0) set({ queued: [...getState().queued, ...restored] });
+    // Reading keeps rows durable; a delivered row's lost drop is completed here.
+    if (consumed.length > 0) await dropTuiSteeringPersist(leadSessionId(), consumed);
     // The conversation closed while the rows were being read: settle them
     // explicitly (rejected + durable mirror released), never leave them parked.
     if (bag.flags?.admission === 'terminal') bag.settleClosedQueue?.();
-    if (droppedDelivered > 0) {
+    if (consumed.length > 0) {
       try {
-        process.stderr.write(`[tui] skipped ${droppedDelivered} already-delivered steering row(s) on restore\n`);
+        process.stderr.write(`[tui] skipped ${consumed.length} already-delivered steering row(s) on restore\n`);
       } catch {
         /* best effort */
       }

package/src/tui/session/tool-approval.mjs

@@ -6,6 +6,11 @@
  * state, so the closure identifiers (state/set/nextId/disposed/timeout) are
  * threaded through the factory argument via getters — never stale snapshots.
  */
+import {
+  humanRequestFields,
+  normalizeHumanResponse,
+} from '../../runtime/agent/orchestrator/session/human-gate/requests.mjs';
+
 export function createToolApproval({ getState, set, nextId, getDisposed, timeoutMs }) {
   const toolApprovalQueue = [];
   let activeToolApproval = null;
@@ -32,6 +37,8 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
       requestedAt: now,
       timeoutMs: requestTimeoutMs,
       expiresAt: requestTimeoutMs === null ? null : now + requestTimeoutMs,
+      // outbound / secret / takeover / permission fields (human-gate/requests.mjs).
+      ...humanRequestFields(input),
     };
   }
   // Every request expires from ITS OWN requestedAt, queued or active. Arming
@@ -41,18 +48,24 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     if (!entry || entry.timer || entry.request?.expiresAt === null) return;
     const remainingMs = Math.max(0, Number(entry.request?.expiresAt || 0) - Date.now());
     entry.timer = setTimeout(() => {
-      finishToolApproval(entry.id, false, 'approval timed out');
+      finishToolApproval(entry.id, false, 'approval timed out', '', undefined, undefined, { timedOut: true });
     }, remainingMs);
     entry.timer.unref?.();
   }
   // Settle one entry: drop its timeout, then hand the waiter its answer. The
   // resolve stays guarded — a waiter whose caller already went away must never
   // take the rest of the queue down with it.
-  function settleToolApproval(entry, approved, reason, answers, reply) {
+  function settleToolApproval(entry, approved, reason, answers, reply, extra, device = '') {
     if (entry?.timer) clearTimeout(entry.timer);
     const result = { approved, reason };
     if (answers !== undefined) result.answers = answers;
     if (reply !== undefined) result.reply = reply;
+    // A human-kind request answers with its canonical response (never a value).
+    if (entry?.request?.remember) {
+      Object.assign(result, normalizeHumanResponse(entry.request, approved, extra));
+      if (device) result.device = device;
+    }
+    if (extra?.timedOut === true) result.timedOut = true;
     try {
       entry.resolve(result);
     } catch {}
@@ -68,7 +81,15 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     armToolApprovalTimeout(entry);
     set({ toolApproval: entry.request });
   }
-  function finishToolApproval(id, approved, reason = '', device = '', answers = undefined, reply = undefined) {
+  function finishToolApproval(
+    id,
+    approved,
+    reason = '',
+    device = '',
+    answers = undefined,
+    reply = undefined,
+    extra = undefined
+  ) {
     const targetId = String(id || '');
     if (activeToolApproval && activeToolApproval.id === targetId) {
       const entry = activeToolApproval;
@@ -79,14 +100,14 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
         ? { id: targetId, approved: approved === true, device: String(device), at: Date.now() }
         : null;
       set({ toolApproval: null, toolApprovalResult });
-      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply);
+      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply, extra, String(device || ''));
       presentNextToolApproval();
       return true;
     }
     const index = toolApprovalQueue.findIndex((entry) => entry.id === targetId);
     if (index >= 0) {
       const [entry] = toolApprovalQueue.splice(index, 1);
-      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply);
+      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply, extra, String(device || ''));
       return true;
     }
     return false;

package/src/tui/session/transcript-intake.mjs

@@ -12,6 +12,7 @@ import {
 import { isLateToolAnnouncement } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { appendPromptHistory } from '../prompt-history-store.mjs';
 import { newTranscriptMessageId } from '../../runtime/shared/transcript-metadata.mjs';
+import { routineTriggerField } from '../../runtime/shared/routine-trigger.mjs';
 import {
   buildExecutionResponseToolItem,
   completionCardFromExecution,
@@ -107,16 +108,19 @@ export function createTranscriptIntake({ getState, flags, pushItem, patchItem, t
     // message reports it) or, for a typed prompt, a new one that goes with
     // the prompt into the model transcript. An injected row with no message
     // id of its own carries none.
+    // A routine fire's row is the prompt the turn persists, like a typed one.
+    const ownsPrompt = origin === 'user' || origin === 'routine';
     let messageId = '';
     if (typeof extra?.messageId === 'string' && extra.messageId) messageId = extra.messageId;
-    else if (origin === 'user') messageId = newTranscriptMessageId();
+    else if (ownsPrompt) messageId = newTranscriptMessageId();
     const transcriptMeta = { ...transcriptRouteMetadata(), ...(messageId ? { messageId } : {}) };
-    if (origin === 'user') flags.pendingTranscriptMeta = transcriptMeta;
+    if (ownsPrompt) flags.pendingTranscriptMeta = transcriptMeta;
     pushItem({
       kind: 'user',
       id,
       text,
       ...transcriptMeta,
+      ...routineTriggerField(extra),
       ...(extra && typeof extra.sender === 'string' && extra.sender ? { sender: extra.sender } : {}),
       ...(extra && typeof extra.device === 'string' && extra.device ? { device: extra.device } : {}),
       // Byte-free attachment metadata (name/mime/size) from the queue entry —

package/src/tui/session/transcript-spill.mjs

@@ -1,6 +1,7 @@
 /**
  * Transcript spill storage, history paging, and session item-state mutations.
  */
+import { randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { Worker } from 'node:worker_threads';
@@ -19,8 +20,11 @@ export const tuiDebug = (msg) => {
   } catch {}
 };
 
+// Item ids outlive the process (queued-input mirror, turn change records), so
+// a restarted process never issues an id again.
+const ID_PREFIX = `it_${randomBytes(4).toString('hex')}_`;
 let _idSeq = 0;
-export const nextId = () => `it_${++_idSeq}`;
+export const nextId = () => `${ID_PREFIX}${++_idSeq}`;
 
 export const TRANSCRIPT_LIVE_ITEM_CAP = 512;
 export const TRANSCRIPT_SPILL_CHUNK_ITEMS = 128;