@jmoyers/harness 0.1.8 → 0.1.10

package/src/control-plane/prompt/thread-title-namer.ts

@@ -0,0 +1,290 @@
+import { createAnthropic, generateText } from '../../../packages/harness-ai/src/index.ts';
+import type { StreamSessionPromptRecord } from '../stream-protocol.ts';
+
+const THREAD_TITLE_ADAPTER_STATE_KEY = 'harnessThreadTitle';
+const MAX_SANITIZED_PROMPT_CHARS = 1200;
+const IMAGE_DATA_URL_PATTERN = /data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=\s]+/giu;
+const MARKDOWN_IMAGE_PATTERN = /!\[[^\]]*\]\([^)]*\)/gu;
+const HTML_IMAGE_PATTERN = /<img\b[^>]*>/giu;
+const LONG_BASE64_LINE_PATTERN = /^[A-Za-z0-9+/=\s]{160,}$/u;
+const TITLE_WORD_PATTERN = /[A-Za-z0-9]+(?:'[A-Za-z0-9]+)*/g;
+const TARGET_TITLE_WORD_COUNT = 2;
+const FALLBACK_FILL_WORDS = ['current', 'thread'] as const;
+const FALLBACK_STOP_WORDS = new Set([
+  'a',
+  'an',
+  'and',
+  'are',
+  'as',
+  'at',
+  'be',
+  'build',
+  'for',
+  'from',
+  'in',
+  'into',
+  'is',
+  'it',
+  'of',
+  'on',
+  'or',
+  'that',
+  'the',
+  'this',
+  'to',
+  'up',
+  'with',
+]);
+const DEFAULT_HAIKU_MODEL_ID = 'claude-3-5-haiku-latest';
+
+interface ThreadTitlePromptHistoryEntry {
+  readonly text: string;
+  readonly observedAt: string;
+  readonly hash: string;
+}
+
+interface ThreadTitleNamerInput {
+  readonly conversationId: string;
+  readonly agentType: string;
+  readonly currentTitle: string;
+  readonly promptHistory: readonly ThreadTitlePromptHistoryEntry[];
+}
+
+export interface ThreadTitleNamer {
+  suggest(input: ThreadTitleNamerInput): Promise<string | null>;
+}
+
+interface AnthropicThreadTitleNamerOptions {
+  readonly apiKey: string;
+  readonly modelId?: string;
+  readonly baseUrl?: string;
+  readonly fetch?: typeof fetch;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function trimmedString(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function historyEntriesFromAdapterState(
+  adapterState: Record<string, unknown>,
+): readonly ThreadTitlePromptHistoryEntry[] {
+  const stored = asRecord(adapterState[THREAD_TITLE_ADAPTER_STATE_KEY]);
+  if (stored === null) {
+    return [];
+  }
+  const promptsRaw = stored['prompts'];
+  if (!Array.isArray(promptsRaw)) {
+    return [];
+  }
+  const parsed: ThreadTitlePromptHistoryEntry[] = [];
+  for (const item of promptsRaw) {
+    const record = asRecord(item);
+    if (record === null) {
+      continue;
+    }
+    const text = trimmedString(record['text']);
+    const observedAt = trimmedString(record['observedAt']);
+    const hash = trimmedString(record['hash']);
+    if (text === null || observedAt === null || hash === null) {
+      continue;
+    }
+    parsed.push({
+      text,
+      observedAt,
+      hash,
+    });
+  }
+  return parsed;
+}
+
+function serializePromptHistory(
+  entries: readonly ThreadTitlePromptHistoryEntry[],
+): Readonly<Record<string, unknown>> {
+  return {
+    prompts: entries.map((entry) => ({
+      text: entry.text,
+      observedAt: entry.observedAt,
+      hash: entry.hash,
+    })),
+  };
+}
+
+function sanitizePromptLine(line: string): string | null {
+  const withoutDataUrl = line
+    .replace(IMAGE_DATA_URL_PATTERN, ' ')
+    .replace(MARKDOWN_IMAGE_PATTERN, ' ')
+    .replace(HTML_IMAGE_PATTERN, ' ')
+    .trim();
+  if (withoutDataUrl.length === 0) {
+    return null;
+  }
+  if (LONG_BASE64_LINE_PATTERN.test(withoutDataUrl)) {
+    return null;
+  }
+  return withoutDataUrl;
+}
+
+export function sanitizePromptForThreadTitle(text: string): string | null {
+  const normalized = text
+    .replace(/\r\n/gu, '\n')
+    .replace(/\r/gu, '\n')
+    .split('\n')
+    .map((line) => sanitizePromptLine(line))
+    .filter((line): line is string => line !== null)
+    .join('\n')
+    .replace(/[ \t]{2,}/gu, ' ')
+    .trim();
+  if (normalized.length === 0) {
+    return null;
+  }
+  if (normalized.length <= MAX_SANITIZED_PROMPT_CHARS) {
+    return normalized;
+  }
+  return `${normalized.slice(0, MAX_SANITIZED_PROMPT_CHARS).trimEnd()}...`;
+}
+
+export function normalizeThreadTitleCandidate(value: string): string | null {
+  const compact = value.trim();
+  if (compact.length === 0) {
+    return null;
+  }
+  const words = compact.match(TITLE_WORD_PATTERN)?.map((word) => word.trim()) ?? [];
+  if (words.length < TARGET_TITLE_WORD_COUNT) {
+    return null;
+  }
+  const filtered = words
+    .map((word) => word.toLowerCase())
+    .filter((word) => word !== 'title' && word.length > 0);
+  if (filtered.length < TARGET_TITLE_WORD_COUNT) {
+    return null;
+  }
+  return filtered.slice(0, TARGET_TITLE_WORD_COUNT).join(' ');
+}
+
+export function fallbackThreadTitleFromPromptHistory(
+  promptHistory: readonly ThreadTitlePromptHistoryEntry[],
+): string {
+  const selected: string[] = [];
+  for (let index = promptHistory.length - 1; index >= 0; index -= 1) {
+    const entry = promptHistory[index];
+    if (entry === undefined) {
+      continue;
+    }
+    const words = entry.text.match(TITLE_WORD_PATTERN) ?? [];
+    for (const rawWord of words) {
+      const normalized = rawWord.toLowerCase();
+      if (normalized.length < 3 || FALLBACK_STOP_WORDS.has(normalized)) {
+        continue;
+      }
+      if (selected.includes(normalized)) {
+        continue;
+      }
+      selected.push(normalized);
+      if (selected.length >= TARGET_TITLE_WORD_COUNT) {
+        return selected.join(' ');
+      }
+    }
+  }
+  for (const fallback of FALLBACK_FILL_WORDS) {
+    selected.push(fallback);
+    if (selected.length >= TARGET_TITLE_WORD_COUNT) {
+      break;
+    }
+  }
+  return selected.slice(0, TARGET_TITLE_WORD_COUNT).join(' ');
+}
+
+export function readThreadTitlePromptHistory(
+  adapterState: Record<string, unknown>,
+): readonly ThreadTitlePromptHistoryEntry[] {
+  return historyEntriesFromAdapterState(adapterState);
+}
+
+export function appendThreadTitlePromptHistory(
+  adapterState: Record<string, unknown>,
+  prompt: StreamSessionPromptRecord,
+): {
+  readonly nextAdapterState: Record<string, unknown>;
+  readonly promptHistory: readonly ThreadTitlePromptHistoryEntry[];
+  readonly added: boolean;
+} {
+  const text = prompt.text === null ? null : sanitizePromptForThreadTitle(prompt.text);
+  const existing = historyEntriesFromAdapterState(adapterState);
+  if (text === null) {
+    return {
+      nextAdapterState: adapterState,
+      promptHistory: existing,
+      added: false,
+    };
+  }
+  const nextHistory: ThreadTitlePromptHistoryEntry[] = [
+    ...existing,
+    {
+      text,
+      observedAt: prompt.observedAt,
+      hash: prompt.hash,
+    },
+  ];
+  const nextAdapterState: Record<string, unknown> = {
+    ...adapterState,
+    [THREAD_TITLE_ADAPTER_STATE_KEY]: serializePromptHistory(nextHistory),
+  };
+  return {
+    nextAdapterState,
+    promptHistory: nextHistory,
+    added: true,
+  };
+}
+
+export function createAnthropicThreadTitleNamer(
+  options: AnthropicThreadTitleNamerOptions,
+): ThreadTitleNamer {
+  const anthropic = createAnthropic({
+    apiKey: options.apiKey,
+    ...(options.baseUrl === undefined ? {} : { baseUrl: options.baseUrl }),
+    ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+  });
+  const model = anthropic(options.modelId ?? DEFAULT_HAIKU_MODEL_ID);
+  return {
+    async suggest(input: ThreadTitleNamerInput): Promise<string | null> {
+      if (input.promptHistory.length === 0) {
+        return null;
+      }
+      const promptLines = input.promptHistory.map(
+        (entry, index) => `${String(index + 1)}. ${entry.text}`,
+      );
+      const response = await generateText({
+        model,
+        system: [
+          'You name active coding-agent threads.',
+          'Use the full user prompt history to keep titles relevant and fresh.',
+          'Stay high-level and avoid low-level implementation details.',
+          'Return exactly 2 words in lowercase with no punctuation and no extra text.',
+        ].join(' '),
+        prompt: [
+          `Agent: ${input.agentType}`,
+          `Current title: ${input.currentTitle}`,
+          `Conversation id: ${input.conversationId}`,
+          'Prompt history (oldest to newest):',
+          ...promptLines,
+          'Return a new title now.',
+        ].join('\n'),
+        maxOutputTokens: 16,
+        temperature: 0,
+      });
+      const normalized = normalizeThreadTitleCandidate(response.text);
+      return normalized ?? fallbackThreadTitleFromPromptHistory(input.promptHistory);
+    },
+  };
+}

package/src/control-plane/stream-command-parser.ts

@@ -421,6 +421,17 @@ function parseConversationUpdate(record: CommandRecord): StreamCommand | null {
   };
 }
 
+function parseConversationTitleRefresh(record: CommandRecord): StreamCommand | null {
+  const conversationId = readString(record['conversationId']);
+  if (conversationId === null) {
+    return null;
+  }
+  return {
+    type: 'conversation.title.refresh',
+    conversationId,
+  };
+}
+
 function parseConversationDelete(record: CommandRecord): StreamCommand | null {
   const conversationId = readString(record['conversationId']);
   if (conversationId === null) {
@@ -1628,6 +1639,7 @@ export const DEFAULT_STREAM_COMMAND_PARSERS: StreamCommandParserRegistry = {
   'conversation.list': parseConversationList,
   'conversation.archive': parseConversationArchive,
   'conversation.update': parseConversationUpdate,
+  'conversation.title.refresh': parseConversationTitleRefresh,
   'conversation.delete': parseConversationDelete,
   'repository.upsert': parseRepositoryUpsert,
   'repository.get': parseRepositoryGet,

package/src/control-plane/stream-protocol.ts

@@ -6,6 +6,8 @@ export type StreamSessionRuntimeStatus = 'running' | 'needs-input' | 'completed'
 export type StreamSessionListSort = 'attention-first' | 'started-desc' | 'started-asc';
 export type StreamTelemetrySource = 'otlp-log' | 'otlp-metric' | 'otlp-trace' | 'history';
 export type StreamTelemetryStatusHint = 'running' | 'completed' | 'needs-input';
+export type StreamPromptCaptureSource = 'otlp-log' | 'hook-notify' | 'history';
+export type StreamPromptConfidence = 'high' | 'medium' | 'low';
 export type StreamSessionControllerType = 'human' | 'agent' | 'automation';
 export type StreamSessionDisplayPhase = 'needs-action' | 'starting' | 'working' | 'idle' | 'exited';
 
@@ -46,6 +48,16 @@ export interface StreamSessionKeyEventRecord {
   statusHint: StreamTelemetryStatusHint | null;
 }
 
+export interface StreamSessionPromptRecord {
+  text: string | null;
+  hash: string;
+  confidence: StreamPromptConfidence;
+  captureSource: StreamPromptCaptureSource;
+  providerEventName: string | null;
+  providerPayloadKeys: string[];
+  observedAt: string;
+}
+
 interface DirectoryUpsertCommand {
   type: 'directory.upsert';
   directoryId?: string;
@@ -107,6 +119,11 @@ interface ConversationUpdateCommand {
   title: string;
 }
 
+interface ConversationTitleRefreshCommand {
+  type: 'conversation.title.refresh';
+  conversationId: string;
+}
+
 interface ConversationDeleteCommand {
   type: 'conversation.delete';
   conversationId: string;
@@ -482,6 +499,7 @@ export type StreamCommand =
   | ConversationListCommand
   | ConversationArchiveCommand
   | ConversationUpdateCommand
+  | ConversationTitleRefreshCommand
   | ConversationDeleteCommand
   | RepositoryUpsertCommand
   | RepositoryGetCommand
@@ -708,6 +726,14 @@ export type StreamObservedEvent =
       directoryId: string | null;
       conversationId: string | null;
     }
+  | {
+      type: 'session-prompt-event';
+      sessionId: string;
+      prompt: StreamSessionPromptRecord;
+      ts: string;
+      directoryId: string | null;
+      conversationId: string | null;
+    }
   | {
       type: 'session-control';
       sessionId: string;
@@ -1057,6 +1083,20 @@ function parseTelemetryStatusHint(value: unknown): StreamTelemetryStatusHint | n
   return undefined;
 }
 
+function parsePromptCaptureSource(value: unknown): StreamPromptCaptureSource | null {
+  if (value === 'otlp-log' || value === 'hook-notify' || value === 'history') {
+    return value;
+  }
+  return null;
+}
+
+function parsePromptConfidence(value: unknown): StreamPromptConfidence | null {
+  if (value === 'high' || value === 'medium' || value === 'low') {
+    return value;
+  }
+  return null;
+}
+
 function parseTelemetrySummary(value: unknown): StreamTelemetrySummary | null | undefined {
   if (value === undefined) {
     return undefined;
@@ -1189,6 +1229,50 @@ function parseSessionKeyEventRecord(value: unknown): StreamSessionKeyEventRecord
   };
 }
 
+function parseSessionPromptRecord(value: unknown): StreamSessionPromptRecord | null {
+  const record = asRecord(value);
+  if (record === null) {
+    return null;
+  }
+  const text = record['text'] === null ? null : readString(record['text']);
+  const hash = readString(record['hash']);
+  const confidence = parsePromptConfidence(record['confidence']);
+  const captureSource = parsePromptCaptureSource(record['captureSource']);
+  const providerEventName =
+    record['providerEventName'] === null ? null : readString(record['providerEventName']);
+  const providerPayloadKeysValue = record['providerPayloadKeys'];
+  const observedAt = readString(record['observedAt']);
+  if (
+    (text === null && record['text'] !== null) ||
+    hash === null ||
+    hash.trim().length === 0 ||
+    confidence === null ||
+    captureSource === null ||
+    (providerEventName === null && record['providerEventName'] !== null) ||
+    !Array.isArray(providerPayloadKeysValue) ||
+    observedAt === null
+  ) {
+    return null;
+  }
+  const providerPayloadKeys: string[] = [];
+  for (const entry of providerPayloadKeysValue) {
+    const key = readString(entry);
+    if (key === null) {
+      return null;
+    }
+    providerPayloadKeys.push(key);
+  }
+  return {
+    text: record['text'] === null ? null : text,
+    hash,
+    confidence,
+    captureSource,
+    providerEventName: record['providerEventName'] === null ? null : providerEventName,
+    providerPayloadKeys,
+    observedAt,
+  };
+}
+
 function parseStreamObservedEvent(value: unknown): StreamObservedEvent | null {
   const record = asRecord(value);
   if (record === null) {
@@ -1609,6 +1693,31 @@ function parseStreamObservedEvent(value: unknown): StreamObservedEvent | null {
     };
   }
 
+  if (type === 'session-prompt-event') {
+    const sessionId = readString(record['sessionId']);
+    const prompt = parseSessionPromptRecord(record['prompt']);
+    const ts = readString(record['ts']);
+    const directoryId = readString(record['directoryId']);
+    const conversationId = readString(record['conversationId']);
+    if (
+      sessionId === null ||
+      prompt === null ||
+      ts === null ||
+      (record['directoryId'] !== null && directoryId === null) ||
+      (record['conversationId'] !== null && conversationId === null)
+    ) {
+      return null;
+    }
+    return {
+      type,
+      sessionId,
+      prompt,
+      ts,
+      directoryId: record['directoryId'] === null ? null : directoryId,
+      conversationId: record['conversationId'] === null ? null : conversationId,
+    };
+  }
+
   if (type === 'session-control') {
     const sessionId = readString(record['sessionId']);
     const action = readString(record['action']);

package/src/control-plane/stream-server-command.ts

@@ -419,6 +419,11 @@ interface ExecuteCommandContext {
     }>;
   };
   readonly streamCursor: number;
+  refreshConversationTitle(conversationId: string): Promise<{
+    conversation: ControlPlaneConversationRecord;
+    status: 'updated' | 'unchanged' | 'skipped';
+    reason: string | null;
+  }>;
   refreshGitStatusForDirectory(
     directory: ControlPlaneDirectoryRecord,
     options?: {
@@ -1403,6 +1408,15 @@ export async function executeStreamServerCommand(
     };
   }
 
+  if (command.type === 'conversation.title.refresh') {
+    const refreshed = await ctx.refreshConversationTitle(command.conversationId);
+    return {
+      conversation: ctx.conversationRecord(refreshed.conversation),
+      status: refreshed.status,
+      reason: refreshed.reason,
+    };
+  }
+
   if (command.type === 'conversation.delete') {
     const existing = ctx.stateStore.getConversation(command.conversationId);
     if (existing === null) {

package/src/control-plane/stream-server-session-runtime.ts

@@ -5,10 +5,12 @@ import type {
   StreamSessionController,
   StreamSessionEvent,
   StreamSessionKeyEventRecord,
+  StreamSessionPromptRecord,
   StreamSessionRuntimeStatus,
   StreamSessionStatusModel,
   StreamSignal,
 } from './stream-protocol.ts';
+import { SessionPromptEngine } from './prompt/session-prompt-engine.ts';
 
 const CLAUDE_NEEDS_INPUT_NOTIFICATION_TYPES = new Set([
   'permissionrequest',
@@ -22,6 +24,7 @@ const CLAUDE_RUNNING_NOTIFICATION_TYPES = new Set([
   'approvalapproved',
   'approvalgranted',
 ]);
+const sessionPromptEngine = new SessionPromptEngine();
 
 interface RuntimeSession {
   id: string;
@@ -83,6 +86,7 @@ interface StreamRuntimeContext {
     state: RuntimeSession,
     keyEvent: StreamSessionKeyEventRecord,
   ): void;
+  publishSessionPromptObservedEvent(state: RuntimeSession, prompt: StreamSessionPromptRecord): void;
   refreshSessionStatusModel(state: RuntimeSession, observedAt: string): void;
   toPublicSessionController(
     controller: StreamSessionController | null,
@@ -557,6 +561,14 @@ export function handleSessionEvent(
       ctx.stateStore.updateConversationAdapterState(sessionState.id, mergedAdapterState);
     }
     if (mapped.type === 'notify') {
+      const promptEvent = sessionPromptEngine.extractFromNotify({
+        agentType: sessionState.agentType,
+        payload: mapped.record.payload,
+        observedAt,
+      });
+      if (promptEvent !== null) {
+        ctx.publishSessionPromptObservedEvent(sessionState, promptEvent);
+      }
       const keyEvent =
         notifyKeyEventFromPayload(sessionState.agentType, mapped.record.payload, observedAt) ??
         unmappedNotifyKeyEventFromPayload(