elanous 0.2.40 → 0.2.42

package/src/dashboard/acp-boot.ts

@@ -135,6 +135,17 @@ export interface DashboardAcpBootDeps {
    *  blocks). Dashboard stashes this into its history store so the
    *  next turn sees real tool evidence. */
   pushTurnToolHistory(messages: readonly LLMMessage[]): void;
+  /** TUI-TOKEN-GUARD-WIRE — replace the chat history store in place after the
+   *  request-size cap compacted it, so the next prompt reads the compacted
+   *  history (not the original 400+ messages). Absent = no write-back. */
+  replaceChatHistory?(messages: readonly ChatMessage[]): void;
+  /** Test seam — request-size cap override (defaults to 400k chars). */
+  requestSizeMaxChars?: number;
+  /** Test seam — the live compactor used for the history write-back. */
+  compactHistoryMessages?: (
+    messages: LLMMessage[],
+    ctx: { sessionId: string; activeModelId?: string },
+  ) => Promise<{ messages: LLMMessage[]; reason: string } | null>;
   /** Optional: agent name/version piped into the ACP handshake. */
   agentName?: string;
   agentVersion?: string;
@@ -219,6 +230,7 @@ export async function bootDashboardAcpSession(
   const gateway = deps.approvalGateway;
   const opts: DashboardSessionOptions = {
     cwd: deps.getCwd(),
+    tuiRouting: true,
     getMessages: ({ sessionId, userText }) => buildTurnMessages(deps, sessionId, userText),
     getTools: ({ sessionId, userText }) => {
       const tools = [...deps.getTools({ userText })];
@@ -229,6 +241,13 @@ export async function bootDashboardAcpSession(
     onTurnComplete: ({ newMessages }) => {
       deps.pushTurnToolHistory(newMessages);
     },
+    ...(deps.replaceChatHistory
+      ? {
+          compactPersistedHistory: ({ sessionId, userText }: { sessionId: string; userText: string }) =>
+            compactDashboardChatHistory(deps, { sessionId, userText }),
+        }
+      : {}),
+    ...(deps.requestSizeMaxChars !== undefined ? { requestSizeMaxChars: deps.requestSizeMaxChars } : {}),
     resolveModel: ({ userText }) => {
       const model = deps.getActiveModel({ userText });
       return model ?? undefined;
@@ -413,6 +432,58 @@ export function createDefaultRequestPermissionHandler(
  *  contains the latest user message for the direct path, so this
  *  helper does NOT append another one; callers that haven't stored
  *  the user message yet should do so before invoking `.send()`. */
+/** TUI-TOKEN-GUARD-WIRE — compact the dashboard chat history store in place.
+ *  Keeps a trailing current-turn user message verbatim (buildTurnMessages
+ *  detects it) and writes the result back through `replaceChatHistory`. */
+export async function compactDashboardChatHistory(
+  deps: Pick<DashboardAcpBootDeps, 'getChatHistory' | 'replaceChatHistory' | 'getActiveModel' | 'compactHistoryMessages'>,
+  ctx: { sessionId: string; userText: string },
+): Promise<{ fired: boolean; reason: string }> {
+  if (!deps.replaceChatHistory) return { fired: false, reason: 'no-history-writer' };
+  const history = [...deps.getChatHistory()];
+  const last = history[history.length - 1];
+  const trailingUser = isCurrentDashboardUser(last, ctx.userText) ? last : undefined;
+  const body = (trailingUser ? history.slice(0, -1) : history) as unknown as LLMMessage[];
+  if (body.length === 0) return { fired: false, reason: 'empty-history' };
+  const activeModelId = deps.getActiveModel({ userText: ctx.userText }) ?? undefined;
+  const compacted = deps.compactHistoryMessages
+    ? await deps.compactHistoryMessages(body, { sessionId: ctx.sessionId, ...(activeModelId ? { activeModelId } : {}) })
+    : await (async () => {
+        const { compactLiveMessages } = await import('../session/request-size-guard.js');
+        const { getUserConfig } = await import('../user-config.js');
+        const chatCfg = getUserConfig().chat;
+        return compactLiveMessages(body, {
+          sessionId: ctx.sessionId,
+          ...(activeModelId ? { activeModelId } : {}),
+          ...(chatCfg?.autoCompact?.preserveLastN !== undefined ? { preserveLastN: chatCfg.autoCompact.preserveLastN } : {}),
+          ...(chatCfg?.compact?.archiveEnabled !== undefined ? { archiveEnabled: chatCfg.compact.archiveEnabled } : {}),
+        });
+      })();
+  if (!compacted) return { fired: false, reason: 'compaction-no-op' };
+  const next = [
+    ...(compacted.messages as unknown as ChatMessage[]),
+    ...(trailingUser ? [trailingUser] : []),
+  ];
+  deps.replaceChatHistory(next);
+  debug.log('dashboard.acp', 'chat-history-compacted', {
+    before: history.length,
+    after: next.length,
+    reason: compacted.reason,
+  });
+  return { fired: true, reason: `history-${compacted.reason}` };
+}
+
+function isCurrentDashboardUser(
+  message: ChatMessage | undefined,
+  userText: string,
+): message is ChatMessage {
+  if (message?.role !== 'user') return false;
+  if (typeof message.content === 'string') return message.content === userText;
+  return message.content.some((block) =>
+    Boolean(block && typeof block === 'object' && 'text' in block
+      && typeof block.text === 'string' && block.text === userText));
+}
+
 function buildTurnMessages(
   deps: DashboardAcpBootDeps,
   sessionId: string,
@@ -425,9 +496,7 @@ function buildTurnMessages(
   // don't need to re-add. This mirrors the dashboard's current flow
   // where `chat.history.push(userMsg)` runs BEFORE streamLLMWithTools.
   const last = history[history.length - 1];
-  const hasTrailingUser = last?.role === 'user'
-    && typeof last.content === 'string'
-    && last.content.includes(userText);
+  const hasTrailingUser = isCurrentDashboardUser(last as ChatMessage | undefined, userText);
   if (hasTrailingUser) {
     return [...preamble, ...history];
   }

package/src/dashboard/classic-sidetab-mission-job.ts

@@ -0,0 +1,58 @@
+import type { PendingTaskNotification } from '../agent/task-notification.js';
+import { debug } from '../debug/log.js';
+import { redactMissionResultPath, type StartedClassicMissionCliJob } from './mission-cli-consumer.js';
+
+export type ClassicMissionNotificationEnqueue = (notification: PendingTaskNotification) => void;
+export const CLASSIC_SIDETAB_MISSION_LABEL = 'sidetab mission';
+
+/** Deliver one eventual sidetab result through the parent's existing task-notification input path. */
+export function enqueueClassicSidetabMissionCompletion(
+  job: StartedClassicMissionCliJob,
+  agent: 'codex' | 'claude',
+  enqueue: ClassicMissionNotificationEnqueue,
+  now: () => number = Date.now,
+): void {
+  let deliveryAttempted = false;
+  const enqueueOnce = (notification: PendingTaskNotification): void => {
+    if (deliveryAttempted) return;
+    deliveryAttempted = true;
+    try {
+      enqueue(notification);
+    } catch {
+      debug.log('classic-sidetab.mission', 'completion-enqueue-failed', {
+        interactionId: job.interactionId,
+        retry: false,
+      });
+    }
+  };
+  const deliver = (result: Awaited<StartedClassicMissionCliJob['completion']>): void => {
+    const finishedAt = now();
+    const state = result.ok ? 'done' : result.status === 'cancelled' ? 'aborted' : 'error';
+    const body = result.ok
+      ? redactMissionResultPath(result.content ?? '', result.path)
+      : redactMissionResultPath(result.error ?? 'Sidetab mission failed; no result was returned', result.path);
+    enqueueOnce({
+      taskId: job.interactionId,
+      agentName: agent === 'codex' ? 'Codex' : 'Claude Code',
+      label: CLASSIC_SIDETAB_MISSION_LABEL,
+      state,
+      output: JSON.stringify({ status: state, body, artifacts: [], id: job.interactionId }),
+      truncated: false,
+      durationMs: Math.max(0, finishedAt - job.startedAt),
+      finishedAt,
+    });
+  };
+  void job.completion.then(deliver).catch(() => {
+    const finishedAt = now();
+    enqueueOnce({
+      taskId: job.interactionId,
+      agentName: agent === 'codex' ? 'Codex' : 'Claude Code',
+      label: CLASSIC_SIDETAB_MISSION_LABEL,
+      state: 'error',
+      output: JSON.stringify({ status: 'error', body: 'Sidetab mission failed before a result was available', artifacts: [], id: job.interactionId }),
+      truncated: false,
+      durationMs: Math.max(0, finishedAt - job.startedAt),
+      finishedAt,
+    });
+  });
+}

package/src/dashboard/classic-sidetab-mission.ts

@@ -0,0 +1,185 @@
+import type { LLMToolSpec } from '../llm.js';
+import { isClassicMissionId, redactMissionResultPath } from './mission-cli-consumer.js';
+
+export const CLASSIC_SIDETAB_MISSION_TOOL_NAME = 'RunSidetabMission';
+export const CLASSIC_SIDETAB_MISSION_CANCEL_TOOL_NAME = 'CancelSidetabMission';
+const AGENT_TOOL_NAME = 'Agent';
+
+export interface ClassicSidetabMissionResult {
+  ok: boolean;
+  status?: 'running' | 'completed' | 'cancelled' | 'failed';
+  path?: string;
+  content?: string;
+  error?: string;
+  interactionId?: string;
+}
+export interface ClassicSidetabMissionToolResult {
+  status: 'running' | 'done' | 'error' | 'aborted';
+  body: string;
+  artifacts: string[];
+  id: string | null;
+}
+
+export interface ClassicSidetabMissionTool {
+  spec: LLMToolSpec;
+  dispatch(args: unknown, context?: ClassicSidetabMissionDispatchContext): Promise<ClassicSidetabMissionToolResult>;
+}
+
+export interface ClassicSidetabMissionIntegration {
+  getTools(tools: readonly LLMToolSpec[]): LLMToolSpec[];
+  dispatchTool(name: string, args: unknown, context?: ClassicSidetabMissionDispatchContext): Promise<ClassicSidetabMissionToolResult> | undefined;
+}
+
+export interface ClassicSidetabMissionDispatchContext {
+  callId?: string;
+}
+
+/** A classic ACP-only tool. Result paths remain internal; the final mission text returns to chat. */
+export function createClassicSidetabMissionTool(
+  runMission: (agent: 'codex' | 'claude', mission: string, context?: ClassicSidetabMissionDispatchContext) => Promise<ClassicSidetabMissionResult>,
+): ClassicSidetabMissionTool {
+  return {
+    spec: {
+      name: CLASSIC_SIDETAB_MISSION_TOOL_NAME,
+      description: 'Run a stateless coding mission with the selected sidetab agent. Return a structured result with status, body, artifacts, and id; the parent chat uses it to continue the original task. Parent-turn cancellation does not cancel the mission; explicit mission-ID cancellation or the one-hour safety timeout can stop it.',
+      parameters: {
+        type: 'object',
+        properties: {
+          agent: { type: 'string', enum: ['codex', 'claude'], description: 'Visible coding agent to run.' },
+          mission: { type: 'string', minLength: 1, description: 'The work to perform.' },
+        },
+        required: ['agent', 'mission'],
+        additionalProperties: false,
+      },
+    },
+    async dispatch(args, context) {
+      const output = (status: ClassicSidetabMissionToolResult['status'], body: string, id: string | null = null): ClassicSidetabMissionToolResult => ({
+        status,
+        body,
+        artifacts: [],
+        id,
+      });
+      if (!args || typeof args !== 'object' || Array.isArray(args)) return output('error', 'arguments must be an object');
+      const input = args as Record<string, unknown>;
+      if (Object.keys(input).some(key => key !== 'agent' && key !== 'mission')) {
+        return output('error', 'arguments contain unsupported fields');
+      }
+      const agent = input.agent;
+      const mission = typeof input.mission === 'string' ? input.mission.trim() : '';
+      if (agent !== 'codex' && agent !== 'claude') return output('error', 'agent must be codex or claude');
+      if (!mission) return output('error', 'mission text is required');
+      let result: ClassicSidetabMissionResult;
+      try {
+        result = await runMission(agent, mission, context);
+      } catch {
+        return output('error', 'Sidetab mission failed before a result was available');
+      }
+      if (result.status === 'running') {
+        if (!result.interactionId) return output('error', 'Sidetab mission started without an interaction ID');
+        const body = result.content?.trim() || 'Independent sidetab job started; this conversation can continue.';
+        return output('running', redactMissionResultPath(body, result.path), result.interactionId);
+      }
+      // The dashboard production seam returns running; this terminal branch serves embedders and tests.
+      if (!result.ok) {
+        return output(result.status === 'cancelled' ? 'aborted' : 'error', 'Sidetab mission failed; no result was returned', result.interactionId ?? null);
+      }
+      const content = result.content?.trim();
+      if (!content) return output('error', 'Sidetab mission completed without an answer', result.interactionId ?? null);
+      if (!result.path) return output('error', 'Sidetab mission completed without an internal result reference', result.interactionId ?? null);
+      const userSafeContent = redactMissionResultPath(content, result.path);
+      if (!result.interactionId) return output('error', 'Sidetab mission completed without an interaction ID');
+      return output('done', userSafeContent, result.interactionId);
+    },
+  };
+}
+
+/** Keep classic ACP tool catalog and dispatch wired through the same production seam. */
+export function createClassicSidetabMissionIntegration(
+  runMission: (agent: 'codex' | 'claude', mission: string, context?: ClassicSidetabMissionDispatchContext) => Promise<ClassicSidetabMissionResult>,
+  cancelMission?: (interactionId: string) => Promise<boolean>,
+): ClassicSidetabMissionIntegration {
+  const tool = createClassicSidetabMissionTool(runMission);
+  const dispatchAgentHand = async (args: unknown, context?: ClassicSidetabMissionDispatchContext): Promise<ClassicSidetabMissionToolResult> => {
+    const output = (status: ClassicSidetabMissionToolResult['status'], body: string, id: string | null = null): ClassicSidetabMissionToolResult => ({
+      status,
+      body,
+      artifacts: [],
+      id,
+    });
+    if (!args || typeof args !== 'object' || Array.isArray(args)) return output('error', 'arguments must be an object');
+    const input = args as Record<string, unknown>;
+    const hand = input.hand;
+    if (hand !== 'codex' && hand !== 'claude') return output('error', 'hand must be internal, codex, or claude');
+    const prompt = typeof input.prompt === 'string' ? input.prompt.trim() : '';
+    if (!prompt) return output('error', 'prompt is required');
+    try {
+      const result = await runMission(hand, prompt, context);
+      if (result.status === 'running') {
+        if (!result.interactionId) return output('error', 'Sidetab mission started without an interaction ID');
+        const body = result.content?.trim() || 'Independent sidetab agent started; this conversation can continue.';
+        return output('running', redactMissionResultPath(body, result.path), result.interactionId);
+      }
+      if (!result.ok) return output(result.status === 'cancelled' ? 'aborted' : 'error', 'Sidetab mission failed; no result was returned', result.interactionId ?? null);
+      const body = result.content?.trim();
+      if (!body) return output('error', 'Sidetab mission completed without an answer', result.interactionId ?? null);
+      if (!result.interactionId) return output('error', 'Sidetab mission completed without an interaction ID');
+      return output('done', redactMissionResultPath(body, result.path), result.interactionId);
+    } catch {
+      return output('error', 'Sidetab mission failed before a result was available');
+    }
+  };
+  const withHandOption = (spec: LLMToolSpec): LLMToolSpec => {
+    const parameters = spec.parameters;
+    const properties = parameters.properties && typeof parameters.properties === 'object' && !Array.isArray(parameters.properties)
+      ? parameters.properties as Record<string, unknown>
+      : {};
+    return {
+      ...spec,
+      description: `${spec.description}\nOptional hand: internal (default), codex, or claude. External hands start a visible sidetab agent and return immediately; completion arrives as a task notification. Parent-turn cancellation does not cancel the mission; explicit mission-ID cancellation or the one-hour safety timeout can stop it.`,
+      parameters: {
+        ...parameters,
+        properties: {
+          ...properties,
+          hand: { type: 'string', enum: ['internal', 'codex', 'claude'], description: 'Execution hand. Defaults to the built-in internal sub-agent.' },
+        },
+      },
+    };
+  };
+  return {
+    getTools: (tools) => [...tools.map(spec => spec.name === AGENT_TOOL_NAME ? withHandOption(spec) : spec), tool.spec, ...(cancelMission ? [{
+      name: CLASSIC_SIDETAB_MISSION_CANCEL_TOOL_NAME,
+      description: 'Explicitly cancel a running sidetab mission. Cancelling the parent conversation turn does not cancel its detached mission.',
+      parameters: {
+        type: 'object',
+        properties: { missionId: { type: 'string', format: 'uuid', description: 'The mission ID returned by RunSidetabMission.' } },
+        required: ['missionId'],
+        additionalProperties: false,
+      },
+    } satisfies LLMToolSpec] : [])],
+    dispatchTool: (name, args, context) => {
+      if (name === CLASSIC_SIDETAB_MISSION_TOOL_NAME) return tool.dispatch(args, context);
+      if (name === AGENT_TOOL_NAME) {
+        if (!args || typeof args !== 'object' || Array.isArray(args)) return dispatchAgentHand(args, context);
+        const hand = (args as Record<string, unknown>).hand;
+        if (hand === undefined || hand === 'internal') return undefined;
+        return dispatchAgentHand(args, context);
+      }
+      if (name !== CLASSIC_SIDETAB_MISSION_CANCEL_TOOL_NAME || !cancelMission) return undefined;
+      return (async () => {
+        if (!args || typeof args !== 'object' || Array.isArray(args)) return { status: 'error', body: 'arguments must be an object', artifacts: [], id: null };
+        const input = args as Record<string, unknown>;
+        if (Object.keys(input).some(key => key !== 'missionId')) return { status: 'error', body: 'arguments contain unsupported fields', artifacts: [], id: null };
+        const missionId = typeof input.missionId === 'string' ? input.missionId : '';
+        if (!isClassicMissionId(missionId)) {
+          return { status: 'error', body: 'missionId must be a UUID', artifacts: [], id: null };
+        }
+        try {
+          const cancelled = await cancelMission(missionId);
+          return { status: cancelled ? 'done' : 'error', body: cancelled ? 'Sidetab mission cancellation requested.' : 'Sidetab mission could not be cancelled.', artifacts: [], id: missionId };
+        } catch {
+          return { status: 'error', body: 'Sidetab mission could not be cancelled.', artifacts: [], id: missionId };
+        }
+      })();
+    },
+  };
+}