farming-code 2.2.20 → 2.2.22

package/backend/acp-transcript.js

@@ -3,6 +3,10 @@ const { createTwoFilesPatch, diffLines } = require('diff');
 const MAX_RENDERED_DIFF_CHARS = 64 * 1024;
 const MAX_INLINE_TOOL_DETAIL_CHARS = 4 * 1024;
 const MAX_EMBEDDED_RESOURCE_TEXT_CHARS = 4 * 1024;
+const MAX_COLLABORATION_AGENTS = 16;
+const MAX_COLLABORATION_ID_CHARS = 160;
+const MAX_COLLABORATION_PATH_CHARS = 512;
+const MAX_COLLABORATION_MESSAGE_CHARS = 160;
 
 function diffBlocks(content) {
   return (Array.isArray(content) ? content : [])
@@ -232,6 +236,66 @@ function generatedMediaTool(entry) {
     || String(output.savedPath || '').includes('/generated_images/');
 }
 
+function boundedCollaborationString(value, maxChars) {
+  return String(value || '').trim().slice(0, maxChars);
+}
+
+function boundedCollaborationIds(value) {
+  const seen = new Set();
+  return (Array.isArray(value) ? value : []).flatMap(item => {
+    const id = boundedCollaborationString(item, MAX_COLLABORATION_ID_CHARS);
+    if (!id || seen.has(id) || seen.size >= MAX_COLLABORATION_AGENTS) return [];
+    seen.add(id);
+    return [id];
+  });
+}
+
+function transcriptCodexToolMeta(entry) {
+  const codex = entry?._meta?.codex && typeof entry._meta.codex === 'object'
+    ? entry._meta.codex
+    : {};
+  const compact = {};
+  if (codex.collaboration && typeof codex.collaboration === 'object') {
+    const rawInput = entry?.rawInput && typeof entry.rawInput === 'object' && !Array.isArray(entry.rawInput)
+      ? entry.rawInput
+      : {};
+    const receiverThreadIds = boundedCollaborationIds(
+      codex.collaboration.receiverThreadIds || rawInput.receiverThreadIds
+    );
+    const rawStates = rawInput.agentsStates && typeof rawInput.agentsStates === 'object' && !Array.isArray(rawInput.agentsStates)
+      ? rawInput.agentsStates
+      : {};
+    const agentsStates = {};
+    const stateIds = boundedCollaborationIds([...receiverThreadIds, ...Object.keys(rawStates)]);
+    for (const threadId of stateIds) {
+      const state = rawStates[threadId] && typeof rawStates[threadId] === 'object'
+        ? rawStates[threadId]
+        : {};
+      agentsStates[threadId] = {
+        status: boundedCollaborationString(state.status, 32),
+        message: boundedCollaborationString(state.message, MAX_COLLABORATION_MESSAGE_CHARS),
+      };
+    }
+    compact.collaboration = {
+      tool: boundedCollaborationString(codex.collaboration.tool, 48),
+      senderThreadId: boundedCollaborationString(
+        codex.collaboration.senderThreadId || rawInput.senderThreadId,
+        MAX_COLLABORATION_ID_CHARS
+      ),
+      receiverThreadIds,
+      agentsStates,
+    };
+  }
+  if (codex.subagent && typeof codex.subagent === 'object') {
+    compact.subagent = {
+      threadId: boundedCollaborationString(codex.subagent.threadId, MAX_COLLABORATION_ID_CHARS),
+      path: boundedCollaborationString(codex.subagent.path, MAX_COLLABORATION_PATH_CHARS),
+      activity: boundedCollaborationString(codex.subagent.activity, 32),
+    };
+  }
+  return Object.keys(compact).length > 0 ? compact : null;
+}
+
 function acpTranscriptToolEntry(entry) {
   if (!entry || entry.type !== 'tool') return entry;
   const detail = detailForTool(entry);
@@ -254,6 +318,8 @@ function acpTranscriptToolEntry(entry) {
   if (entry?._meta?.farming_patch_decisions) {
     meta.farming_patch_decisions = JSON.parse(JSON.stringify(entry._meta.farming_patch_decisions));
   }
+  const codexMeta = transcriptCodexToolMeta(entry);
+  if (codexMeta) meta.codex = codexMeta;
   return {
     id: String(entry.id || ''),
     type: 'tool',

package/backend/agent-lifecycle-journal.js

@@ -0,0 +1,133 @@
+const MAX_LIFECYCLE_OPERATIONS = 32;
+const TERMINAL_OPERATION_STATES = new Set(['succeeded', 'failed', 'cancelled']);
+
+function compactLifecycleEntries(entries) {
+  const recentIds = new Set(entries.slice(-MAX_LIFECYCLE_OPERATIONS).map(operation => operation.id));
+  return entries.filter(operation => (
+    recentIds.has(operation.id)
+    || operation.requestKey.startsWith('create-request:')
+  ));
+}
+
+function normalizeOperation(operation) {
+  if (!operation || typeof operation !== 'object') return null;
+  const id = String(operation.id || '').trim();
+  const type = String(operation.type || '').trim();
+  const state = String(operation.state || '').trim();
+  if (!id || !type || !state) return null;
+  return {
+    id,
+    type,
+    state,
+    requestKey: String(operation.requestKey || ''),
+    request: operation.request && typeof operation.request === 'object'
+      ? JSON.parse(JSON.stringify(operation.request))
+      : {},
+    result: operation.result && typeof operation.result === 'object'
+      ? JSON.parse(JSON.stringify(operation.result))
+      : null,
+    startedAt: Number(operation.startedAt) || 0,
+    updatedAt: Number(operation.updatedAt) || 0,
+    finishedAt: Number(operation.finishedAt) || null,
+    error: String(operation.error || ''),
+  };
+}
+
+function lifecycleJournal(source) {
+  const raw = source?.lifecycleJournal;
+  const entries = Array.isArray(raw?.entries)
+    ? compactLifecycleEntries(raw.entries.map(normalizeOperation).filter(Boolean))
+    : [];
+  return {
+    sequence: Math.max(0, Math.floor(Number(raw?.sequence) || 0)),
+    entries,
+  };
+}
+
+function activeLifecycleOperation(source) {
+  const journal = lifecycleJournal(source);
+  for (let index = journal.entries.length - 1; index >= 0; index -= 1) {
+    const operation = journal.entries[index];
+    if (!TERMINAL_OPERATION_STATES.has(operation.state)) return operation;
+  }
+  return null;
+}
+
+function latestLifecycleOperation(source) {
+  const entries = lifecycleJournal(source).entries;
+  return entries.length > 0 ? entries[entries.length - 1] : null;
+}
+
+function beginLifecycleOperation(source, type, requestKey, request = {}, now = Date.now()) {
+  const journal = lifecycleJournal(source);
+  const active = activeLifecycleOperation({ lifecycleJournal: journal });
+  if (active) {
+    if (active.type === type && active.requestKey === String(requestKey || '')) {
+      source.lifecycleJournal = journal;
+      return { operation: active, joined: true };
+    }
+    return { conflict: active };
+  }
+
+  journal.sequence += 1;
+  const operation = {
+    id: `aop_${journal.sequence}`,
+    type: String(type || ''),
+    state: 'pending',
+    requestKey: String(requestKey || ''),
+    request: request && typeof request === 'object' ? JSON.parse(JSON.stringify(request)) : {},
+    result: null,
+    startedAt: now,
+    updatedAt: now,
+    finishedAt: null,
+    error: '',
+  };
+  journal.entries.push(operation);
+  journal.entries = compactLifecycleEntries(journal.entries);
+  source.lifecycleJournal = journal;
+  return { operation, joined: false };
+}
+
+function transitionLifecycleOperation(source, operationId, state, error = '', now = Date.now()) {
+  const journal = lifecycleJournal(source);
+  const operation = journal.entries.find(candidate => candidate.id === operationId);
+  if (!operation) return null;
+  if (TERMINAL_OPERATION_STATES.has(operation.state)) return operation;
+  operation.state = String(state || operation.state);
+  operation.error = String(error || '');
+  operation.updatedAt = now;
+  operation.finishedAt = TERMINAL_OPERATION_STATES.has(operation.state) ? now : null;
+  if (
+    operation.type === 'create'
+    && operation.finishedAt !== null
+    && operation.request
+    && Object.prototype.hasOwnProperty.call(operation.request, 'previousState')
+  ) {
+    delete operation.request.previousState;
+  }
+  source.lifecycleJournal = journal;
+  return operation;
+}
+
+function setLifecycleOperationResult(source, operationId, result, now = Date.now()) {
+  const journal = lifecycleJournal(source);
+  const operation = journal.entries.find(candidate => candidate.id === operationId);
+  if (!operation) return null;
+  operation.result = result && typeof result === 'object'
+    ? JSON.parse(JSON.stringify(result))
+    : null;
+  operation.updatedAt = now;
+  source.lifecycleJournal = journal;
+  return operation;
+}
+
+module.exports = {
+  MAX_LIFECYCLE_OPERATIONS,
+  TERMINAL_OPERATION_STATES,
+  activeLifecycleOperation,
+  beginLifecycleOperation,
+  latestLifecycleOperation,
+  lifecycleJournal,
+  setLifecycleOperationResult,
+  transitionLifecycleOperation,
+};