@forloop-cc/forloop-opencode-plugin-planner 2.2.17 → 2.2.19

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@forloop-cc/forloop-opencode-plugin-planner",
-  "version": "2.2.17",
+  "version": "2.2.19",
   "description": "ForLoop integration plugin for opencode — Sprint, story, and agent tools for the ForLoop platform",
   "type": "module",
   "license": "MIT",

package/plugins/capabilities/api-client.ts

@@ -119,7 +119,6 @@ export class ForLoopAPIClient {
 
   private async ensureOpencodeApiToken(endpoint: string): Promise<void> {
     if (this.tokenType !== 'jwt') return;
-    if (!endpoint.startsWith('/api/opencode/')) return;
     if (endpoint.startsWith('/api/opencode/auth/tokens')) return;
 
     if (!this.jwtExchangePromise) {
@@ -221,7 +220,20 @@ export class ForLoopAPIClient {
           throw error;
         }
 
-        return response.json();
+        if (response.status === 204) {
+          return undefined as unknown as T;
+        }
+
+        const text = await response.text();
+        if (!text) {
+          return undefined as unknown as T;
+        }
+
+        try {
+          return JSON.parse(text) as T;
+        } catch {
+          throw new APIError('invalid_response', 'Failed to parse response body as JSON', 502);
+        }
       } catch (error) {
         lastError = error as Error;
         
@@ -456,8 +468,9 @@ export class ForLoopAPIClient {
   async getConversationHistory(params?: ConversationHistoryParams): Promise<any> {
     const query = new URLSearchParams();
     if (params?.sprintId) query.append('sprintId', String(params.sprintId));
+    if (params?.conversationId) query.append('conversationId', String(params.conversationId));
     if (params?.limit) query.append('limit', String(params.limit));
-    return this.request(`/api/opencode/messages?${query}`);
+    return this.request(`/api/opencode/conversations/context?${query}`);
   }
 
   async clearConversationHistory(params?: ClearHistoryParams): Promise<any> {
@@ -623,6 +636,7 @@ export interface WriteConversationEventInput {
 
 export interface ConversationHistoryParams {
   sprintId?: number;
+  conversationId?: string;
   limit?: number;
 }
 

package/plugins/capabilities/conversationId.ts

@@ -0,0 +1,135 @@
+// GENERATED from server_lambda_shared/src/services/conversationId.ts — do not edit. Run: node scripts/sync_conversation_id.mjs
+// Single source of truth for conversation/context ids. Dependency-free.
+export const PLANNER_AGENT_KEY = 'forLoopPlanner'
+export const A2A_PEER_AGENT_KEY = 'a2a-peer'
+
+const SENDER_TYPES = new Set(['user', 'agent', 'system', 'appuser'])
+
+export type SenderType = 'user' | 'agent' | 'system' | 'appuser'
+export type ConversationIdKind = 'agent' | 'appuser' | 'meeting' | 'summary' | 'unknown'
+
+export interface ParsedConversationId {
+  kind: ConversationIdKind
+  raw: string
+  sprintId: number | null
+  agentKey?: string
+  senderType?: string
+  senderId?: string
+  sessionId?: string | null
+  userId?: string
+  meetingId?: string
+  threadKey?: string
+  range?: string
+}
+
+export interface BuildAgentThreadInput {
+  sprintId: number
+  agentKey: string
+  senderType: SenderType
+  senderId: string | number
+  sessionId?: string | null
+}
+
+export function buildAgentThreadId(input: BuildAgentThreadInput): string {
+  const base = `sprint:${input.sprintId}:agent:${input.agentKey}:${input.senderType}:${input.senderId}`
+  const session = input.sessionId != null && String(input.sessionId).trim() ? String(input.sessionId).trim() : null
+  return session ? `${base}:session:${session}` : base
+}
+
+export function buildAppUserThreadId(sprintId: number, agentPublicId: string, userId: number | string): string {
+  return `sprint:${sprintId}:agent:${agentPublicId}:appuser:${userId}`
+}
+
+export function buildMeetingThreadId(sprintId: number, meetingId: string, userId: number | string): string {
+  return `sprint:${sprintId}:meeting:${meetingId}:summary:user:${userId}`
+}
+
+export function buildSummaryId(input: { sprintId: number; agentKey: string; threadKey?: string; rangeStart: number; rangeEnd: number }): string {
+  const prefix = `sprint:${input.sprintId}:agent:${input.agentKey}:summary:`
+  return input.threadKey
+    ? `${prefix}${input.threadKey}:${input.rangeStart}-${input.rangeEnd}`
+    : `${prefix}${input.rangeStart}-${input.rangeEnd}`
+}
+
+export function webAppThreadId(sprintId: number, userId: number | string): string {
+  return buildAgentThreadId({ sprintId, agentKey: PLANNER_AGENT_KEY, senderType: 'user', senderId: userId })
+}
+
+const isNum = (v: string | undefined): number | null => {
+  if (v === undefined || !/^-?\d+$/.test(v)) return null
+  return Number(v)
+}
+
+export function parseConversationId(id: string): ParsedConversationId {
+  const raw = String(id ?? '')
+  const parts = raw.split(':')
+  const unknown: ParsedConversationId = { kind: 'unknown', raw, sprintId: null }
+  if (parts[0] !== 'sprint' || parts.length < 3) return unknown
+  const sprintId = isNum(parts[1])
+  if (sprintId === null) return unknown
+
+  if (parts[2] === 'appuser') {
+    const userId = parts.slice(3).join(':')
+    if (!userId) return unknown
+    return { kind: 'appuser', raw, sprintId, userId }
+  }
+  if (parts[2] === 'meeting' && parts.length >= 4 && parts[3]) {
+    const userId = parts[4] === 'summary' && parts[5] === 'user' ? parts.slice(6).join(':') : undefined
+    return { kind: 'meeting', raw, sprintId, meetingId: parts[3], ...(userId ? { userId } : {}) }
+  }
+  if (parts[2] === 'agent' && parts.length >= 6) {
+    const agentKey = parts[3]
+    if (!agentKey) return unknown
+    const senderType = parts[4]
+    const sessionIdx = parts.indexOf('session', 5)
+    const hasSession = sessionIdx >= 5
+    const senderId = (hasSession ? parts.slice(5, sessionIdx) : parts.slice(5)).join(':')
+    const sessionId = hasSession ? parts.slice(sessionIdx + 1).join(':') || null : null
+    if (senderType === 'summary') {
+      const rest = parts.slice(5).join(':')
+      // Legacy: `sprint:{id}:agent:{agent}:summary:{start}-{end}` (no threadKey).
+      if (/^\d+-\d+$/.test(rest)) {
+        return { kind: 'summary', raw, sprintId, agentKey, range: rest }
+      }
+      // Thread-scoped: `...:summary:{threadKey}:{start}-{end}` where threadKey contains colons.
+      const m = rest.match(/^(.*):(\d+-\d+)$/)
+      if (m) {
+        return { kind: 'summary', raw, sprintId, agentKey, threadKey: m[1], range: m[2] }
+      }
+      return { kind: 'summary', raw, sprintId, agentKey, ...(rest ? { threadKey: rest } : {}) }
+    }
+    if (!senderId || !SENDER_TYPES.has(senderType)) return unknown
+    return { kind: 'agent', raw, sprintId, agentKey, senderType, senderId, sessionId }
+  }
+  return unknown
+}
+
+export function isCanonicalConversationId(id: string): boolean {
+  return parseConversationId(id).kind !== 'unknown'
+}
+
+export function isAppUserThread(id: string): boolean {
+  const p = parseConversationId(id)
+  return p.kind === 'appuser' || (p.kind === 'agent' && p.senderType === 'appuser')
+}
+
+export function validateConversationId(id: string): { ok: true } | { ok: false; error: string } {
+  return isCanonicalConversationId(id) ? { ok: true } : { ok: false, error: 'Invalid conversationId format' }
+}
+
+// One thread per producer: the producer's canonical base id with any `:session:`
+// suffix stripped, so each sender (web human, AI user, chrome extension, peer,
+// appuser) owns its own channel and only its own sessions collapse into it.
+// Producers are never folded into one another.
+export function conversationGroupKey(id: string): string | null {
+  const p = parseConversationId(id)
+  if (p.kind === 'unknown' || p.sprintId === null) return null
+  if (p.kind === 'agent') {
+    if (!p.agentKey) return null
+    return `sprint:${p.sprintId}:agent:${p.agentKey}:${p.senderType}:${p.senderId}`
+  }
+  if (p.kind === 'appuser') return id
+  if (p.kind === 'meeting') return id
+  // summary rows are attributed separately, not listed as channels
+  return null
+}

package/plugins/capabilities/conversationInjection.ts

@@ -0,0 +1,85 @@
+// GENERATED from server_lambda_shared/src/services/conversationInjection.ts — do not edit. Run: node scripts/sync_conversation_id.mjs
+export interface InjectionBudget {
+  maxTurns?: number
+  maxSummaryChars?: number
+  maxCharsPerTurn?: number
+}
+
+export interface InjectedSummary {
+  text: string
+  roundsCovered: string | null
+  timestamp?: Date | string | null
+  owner?: string
+}
+
+export interface InjectedTurn {
+  id?: number
+  conversationId?: string
+  timestamp?: Date | string | null
+  userMessage: string
+  agentResponse: string
+  metadata?: unknown
+}
+
+export interface InjectionSource {
+  summaries: InjectedSummary[]
+  turns: InjectedTurn[]
+}
+
+export interface InjectedContext {
+  summaries: InjectedSummary[]
+  turns: InjectedTurn[]
+}
+
+function trunc(s: string, n: number): string {
+  return Number.isFinite(n) && n > 0 && s.length > n ? s.slice(0, n) + '... [truncated]' : s
+}
+
+export function buildInjectedContext(view: InjectionSource, budget: InjectionBudget = {}): InjectedContext {
+  const coveredEnd = view.summaries.reduce((max, s) => {
+    const end = Number(String(s.roundsCovered || '').split('-')[1])
+    return Number.isFinite(end) && end > max ? end : max
+  }, 0)
+  const maxTurns = budget.maxTurns ?? Infinity
+  const maxPer = budget.maxCharsPerTurn ?? Infinity
+  const maxSummary = budget.maxSummaryChars ?? Infinity
+  const turns = view.turns
+    .filter((_, i) => i + 1 > coveredEnd) // positional: drop turns already covered by a summary
+    .slice(-maxTurns)
+    .map((t) => ({ ...t, userMessage: trunc(t.userMessage, maxPer), agentResponse: trunc(t.agentResponse, maxPer) }))
+  // The summary block is capped in aggregate: join all summaries into one text
+  // and truncate once, so the injected context holds a single capped summary.
+  const combined = view.summaries.map((s) => s.text).filter(Boolean).join('\n\n')
+  const capped = trunc(combined, maxSummary)
+  const anchor = view.summaries.reduce((best, s) => {
+    const e = Number(String(s.roundsCovered || '').split('-')[1])
+    const b = Number(String(best?.roundsCovered || '').split('-')[1])
+    return Number.isFinite(e) && (!best || !Number.isFinite(b) || e > b) ? s : best
+  }, undefined as InjectedSummary | undefined)
+  const summaries = capped && anchor ? [{ ...anchor, text: capped }] : []
+  return { summaries, turns }
+}
+
+export function renderChatMessages(ctx: InjectedContext): { role: 'system' | 'user' | 'assistant'; content: string }[] {
+  const out: { role: 'system' | 'user' | 'assistant'; content: string }[] = []
+  for (const s of ctx.summaries) if (s.text) out.push({ role: 'system', content: s.text })
+  for (const t of ctx.turns) {
+    if (t.userMessage) out.push({ role: 'user', content: t.userMessage })
+    if (t.agentResponse) out.push({ role: 'assistant', content: t.agentResponse })
+  }
+  return out
+}
+
+export function renderPromptSection(ctx: InjectedContext): string {
+  const parts: string[] = []
+  const summaryText = ctx.summaries.map((s) => s.text).filter(Boolean).join('\n\n')
+  if (summaryText) { parts.push('Conversation summary:'); parts.push(summaryText) }
+  if (ctx.turns.length) {
+    parts.push('Conversation history:')
+    for (const t of ctx.turns) {
+      if (t.userMessage) parts.push(`user: ${t.userMessage}`)
+      if (t.agentResponse) parts.push(`assistant: ${t.agentResponse}`)
+    }
+  }
+  return parts.join('\n')
+}

package/plugins/hooks/message-recorder.ts

@@ -1,5 +1,6 @@
 import { ForLoopAPIClient } from '../capabilities/api-client';
 import type { WriteConversationEventInput } from '../capabilities/api-client';
+import { buildAgentThreadId } from '../capabilities/conversationId';
 import { isLambdaExecution } from '../capabilities/config';
 import fs from 'fs';
 import path from 'path';
@@ -25,7 +26,16 @@ function getActor(): { senderType: string; senderId: string } {
 
 function buildConversationId(sprintId: number, agent: string, sessionId: string): string {
   const actor = getActor();
-  return `sprint:${sprintId}:agent:${agent}:${actor.senderType}:${actor.senderId}`;
+  // NOTE: sessionId is intentionally NOT part of the thread id — it is stored in
+  // metadata so all of a conversation's turns share one thread (memory preload
+  // keys on this base id). `sessionId` is passed to the write call separately.
+  return buildAgentThreadId({
+    sprintId,
+    agentKey: agent,
+    senderType: (actor.senderType as 'user' | 'agent' | 'system') || 'user',
+    senderId: actor.senderId || 'unknown',
+    sessionId: null,
+  });
 }
 
 function readActiveSprintId(): number | null {
@@ -75,6 +85,22 @@ function extractTextFromParts(parts: any[]): string {
     .join('');
 }
 
+function isPendingUserMessagePart(messageID: string): boolean {
+  if (!messageID) return false;
+  for (const pending of userMessageBuffer.values()) {
+    if (pending.messageId === messageID) return true;
+  }
+  return false;
+}
+
+function looksLikeInjectedContext(text: string): boolean {
+  return (
+    text.includes('Current user request:') ||
+    text.includes('Conversation history:') ||
+    text.includes('Conversation summary:')
+  );
+}
+
 export function createChatMessageHook(client: ForLoopAPIClient) {
   return async (input: any, output: any) => {
     const sprintId = readActiveSprintId();
@@ -110,6 +136,7 @@ export function createEventHook(client: ForLoopAPIClient) {
   const textBuffer = new Map<string, string>();
   const readyToStream = new Set<string>(); // messageIDs that have passed the context phase
   const directSentText = new Map<string, string>(); // trackingId → last full text sent via direct HTTP
+  const directSentIndex = new Map<string, number>(); // trackingId → next chunk index
 
   const sendStreamDelta = (sprintId: number, trackingId: string, taskId: string, fullText: string) => {
     const lastSent = directSentText.get(trackingId) || '';
@@ -117,12 +144,14 @@ export function createEventHook(client: ForLoopAPIClient) {
     const delta = fullText.startsWith(lastSent) ? fullText.substring(lastSent.length) : fullText;
     if (!delta) return;
     directSentText.set(trackingId, fullText);
+    const index = directSentIndex.get(trackingId) || 0;
+    directSentIndex.set(trackingId, index + 1);
     client.sendStreamChunk({
       taskId: taskId || '',
       trackingId,
       sprintId,
       chunk: delta,
-      index: 0,
+      index,
     }).catch((err: Error) => {
       console.warn('[ForLoop] Direct stream chunk failed:', err.message);
     });
@@ -153,12 +182,19 @@ export function createEventHook(client: ForLoopAPIClient) {
             break;
           }
 
-          // Skip the initial context text (the conversation history loaded by the agent).
-          // Context text is massive (30K+ chars), assistant responses are small (<5K).
-          // Also track that we've seen the context and subsequent text is streamable.
-          const textLen = (part.text || '').length;
-          if (!readyToStream.has(messageID) && textLen > 5000) {
-            if (debugStream) console.error('[stream-event] skipping context text', { trackingId, messageID, textLen });
+          // Text parts that belong to the pending user message carry the
+          // injected conversation history — never stream them as agent output.
+          if (isPendingUserMessagePart(messageID || '')) {
+            if (debugStream) console.error('[stream-event] skipping user-message text', { trackingId, messageID });
+            break;
+          }
+
+          // Fallback: the very first text part of a message that carries the
+          // injected-prompt markers is a replay of the loaded context, not a
+          // genuine response. A length threshold alone would discard long
+          // assistant replies.
+          if (!readyToStream.has(messageID) && looksLikeInjectedContext(part.text || '')) {
+            if (debugStream) console.error('[stream-event] skipping injected context text', { trackingId, messageID });
             readyToStream.add(messageID); // mark as past context
             break;
           }
@@ -166,6 +202,7 @@ export function createEventHook(client: ForLoopAPIClient) {
           readyToStream.add(messageID);
           const current = textBuffer.get(part.messageID) || '';
           textBuffer.set(part.messageID, part.text || current);
+          const textLen = (part.text || '').length;
           if (debugStream) console.error('[stream-event] writing chunk', { trackingId, textLen });
 
           // Send delta directly for real-time streaming (primary path)
@@ -186,37 +223,12 @@ export function createEventHook(client: ForLoopAPIClient) {
             preview: bufferedText.substring(0, 500),
           });
 
-          const pendingUserMsg = userMessageBuffer.get(info.sessionID);
           userMessageBuffer.delete(info.sessionID);
 
-          if (!pendingUserMsg) {
-            console.log('[ForLoop] Skipping write — no buffered user message for this session (stream handler handles the save)');
-            break;
-          }
-
-          const conversationId = buildConversationId(
-            sprintId,
-            info.agent || 'unknown',
-            info.sessionID
-          );
-          writeConversationTurn(client, {
-            operation: 'append_turn',
-            sprintId,
-            targetAgent: info.agent ? normalizeAgentKey(info.agent) : 'unknown',
-            actor: getActor(),
-            conversationId,
-            sessionId: info.sessionID,
-            messageId: info.id,
-            userMessage: pendingUserMsg.content,
-            agentResponse: bufferedText,
-            metadata: {
-              source: 'opencode-plugin',
-              agent: info.agent ? normalizeAgentKey(info.agent) : null,
-              model: info.model || null,
-              userMessageId: pendingUserMsg.messageId || null,
-              recordedAt: info.time?.created ?? Date.now(),
-            },
-          }, 3);
+          // In the lambda streaming path the stream handler owns persistence
+          // (it has the authoritative conversationId + actor). Do not write here
+          // too, or every turn is recorded twice.
+          console.log('[ForLoop] Skipping plugin write — stream handler handles the save');
           break;
         }
         case 'message.removed': {

package/plugins/tools/agent-suggestion-tools.ts

@@ -2,6 +2,7 @@ import { tool } from '@opencode-ai/plugin';
 import { ForLoopAPIClient } from '../capabilities/api-client';
 import { resolveSprintId } from '../capabilities/context-resolver';
 import { validateToken } from '../capabilities/auth';
+import { renderPromptSection } from '../capabilities/conversationInjection';
 
 export function createAgentSuggestTool(client: ForLoopAPIClient) {
   return tool({
@@ -173,47 +174,36 @@ export function createConversationHistoryTool(client: ForLoopAPIClient) {
       const resolution = await resolveSprintId(args.sprintId, context.directory);
       const sprintId = resolution.sprintId || args.sprintId;
 
+      if (typeof sprintId !== 'number' || !Number.isInteger(sprintId) || sprintId <= 0) {
+        return [
+          '❌ No sprint ID provided.',
+          '',
+          'Please specify a sprint ID using one of these methods:',
+          '  1. Pass --sprintId flag',
+          '  2. Set FORLOOP_SPRINT_ID environment variable',
+          '  3. Use a git branch named sprint-XXX (e.g., sprint-123)',
+        ].join('\n');
+      }
+
       try {
         const history = await client.getConversationHistory({
           sprintId,
           limit: args.limit,
         });
 
-        const messages = history.messages || [];
-        if (messages.length === 0) {
+        const summaries = history?.summaries || [];
+        const turns = history?.turns || [];
+        if (summaries.length === 0 && turns.length === 0) {
           return 'No conversation history found.';
         }
 
+        const section = renderPromptSection({ summaries, turns });
         const lines = [
-          `💬 Conversation History (${history.total || messages.length} total)`,
+          `💬 Conversation History (${history.total ?? turns.length} total, ${turns.length} turns)`,
           '',
+          section,
         ];
 
-        for (const msg of messages.slice(0, args.limit)) {
-          const preview = (msg.userMessage || 'No message').substring(0, 80);
-          const hasResponse = msg.agentResponse && msg.agentResponse.trim();
-
-          lines.push(`📌 **${preview}**${preview.length >= 80 ? '...' : ''}`);
-
-          if (msg.conversationId) {
-            const agentMatch = msg.conversationId.match(/agent:([^:]+)/);
-            if (agentMatch) {
-              lines.push(`   Agent: ${agentMatch[1]} | ${formatDate(msg.timestamp)}`);
-            } else {
-              lines.push(`   ${formatDate(msg.timestamp)}`);
-            }
-          } else {
-            lines.push(`   ${formatDate(msg.timestamp)}`);
-          }
-
-          if (hasResponse) {
-            const respPreview = msg.agentResponse.substring(0, 100);
-            lines.push(`   → ${respPreview}${msg.agentResponse.length > 100 ? '...' : ''}`);
-          }
-
-          lines.push('');
-        }
-
         return lines.join('\n');
       } catch (error: any) {
         return `❌ Error: ${error.message}`;
@@ -264,12 +254,3 @@ export function createClearHistoryTool(client: ForLoopAPIClient) {
     },
   });
 }
-
-function formatDate(dateString: string): string {
-  return new Date(dateString).toLocaleDateString('en-US', {
-    month: 'short',
-    day: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit',
-  });
-}