@forloop-cc/forloop-opencode-plugin-planner 2.2.18 → 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.18",
+  "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/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 {
@@ -213,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({
@@ -191,28 +192,18 @@ export function createConversationHistoryTool(client: ForLoopAPIClient) {
         });
 
         const summaries = history?.summaries || [];
-        const messages = history?.messages || [];
-        if (summaries.length === 0 && messages.length === 0) {
+        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 summary of summaries) {
-          lines.push('📋 **Sprint summary**', '', summary, '');
-        }
-
-        for (const msg of messages.slice(0, args.limit)) {
-          const badge = msg.role === 'assistant' ? '🤖 Assistant' : '👤 User';
-          const content = String(msg.content || '');
-          const preview = content.substring(0, 120);
-          lines.push(`${badge}: ${preview}${content.length > 120 ? '...' : ''}`);
-          lines.push('');
-        }
-
         return lines.join('\n');
       } catch (error: any) {
         return `❌ Error: ${error.message}`;