@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/agent/agent-context-sources.ts

@@ -0,0 +1,253 @@
+import replayPolicy = require('./context-replay-policy');
+
+type MessageTimestamp = string | number;
+
+interface ReplayFields {
+  readonly contextSafe?: unknown;
+  readonly replayPolicy?: unknown;
+  readonly [key: string]: unknown;
+}
+
+interface ContextMessage {
+  readonly id?: unknown;
+  readonly topic?: unknown;
+  readonly timestamp: MessageTimestamp;
+  readonly sender: string;
+  readonly metadata?: ReplayFields | null;
+  readonly content?: {
+    readonly text?: string | null;
+    readonly data?: ReplayFields | null;
+  } | null;
+}
+
+interface ContextSource {
+  topic: string;
+  sender?: unknown;
+  since?: unknown;
+  amount?: number;
+  limit?: number;
+  strategy?: string;
+  compactAmount?: number;
+  compactStrategy?: string;
+  priority?: string;
+}
+
+interface SourceCluster {
+  id: string;
+  createdAt: number;
+}
+
+interface MessageQuery {
+  cluster_id: string;
+  topic: string;
+  sender?: unknown;
+  since?: unknown;
+  afterId?: unknown;
+  throughId?: unknown;
+}
+
+interface SourceMessageBus {
+  query(criteria: MessageQuery): ContextMessage[];
+}
+
+interface SourceSelectionOptions {
+  compact?: boolean;
+}
+
+interface SourceSelection {
+  amount: number | undefined;
+  strategy: string;
+}
+
+interface SourceMessageParams {
+  source: ContextSource;
+  messageBus: SourceMessageBus;
+  cluster: SourceCluster;
+  lastTaskEndTime?: number | null | undefined;
+  lastAgentStartTime?: number | null | undefined;
+  afterId?: unknown;
+  throughId?: unknown;
+  triggeringMessageId?: unknown;
+  compact?: boolean;
+}
+
+interface SourcePackParams extends Omit<SourceMessageParams, 'compact'> {
+  index: number;
+}
+
+interface SourcePack {
+  id: string;
+  section: 'sources';
+  priority: string;
+  render(): string;
+  compact(): string;
+}
+
+const { isReplayableMessage } = replayPolicy;
+
+function resolveSourceSince(
+  source: ContextSource,
+  cluster: SourceCluster,
+  lastTaskEndTime: number | null | undefined,
+  lastAgentStartTime: number | null | undefined
+): unknown {
+  const sinceValue = source.since;
+
+  if (sinceValue === 'cluster_start') {
+    return cluster.createdAt;
+  }
+
+  if (sinceValue === 'last_task_end') {
+    return lastTaskEndTime || cluster.createdAt;
+  }
+
+  if (sinceValue === 'last_agent_start') {
+    return lastAgentStartTime ? lastAgentStartTime + 1 : cluster.createdAt;
+  }
+
+  if (typeof sinceValue === 'string') {
+    const parsed = Date.parse(sinceValue);
+    if (Number.isNaN(parsed)) {
+      throw new Error(
+        `Unknown context source "since" value "${sinceValue}" for topic ${source.topic}. ` +
+          'Use cluster_start, last_task_end, last_agent_start, or an ISO timestamp.'
+      );
+    }
+    return parsed;
+  }
+
+  return sinceValue;
+}
+
+function formatSourceMessagesSection(source: ContextSource, messages: ContextMessage[]): string {
+  let context = `\n## Messages from topic: ${source.topic}\n\n`;
+
+  for (const msg of messages) {
+    context += `[${new Date(msg.timestamp).toISOString()}] ${msg.sender}:\n`;
+    if (msg.content?.text) {
+      context += `${msg.content.text}\n`;
+    }
+    if (msg.content?.data) {
+      context += `Data: ${JSON.stringify(msg.content.data, null, 2)}\n`;
+    }
+    context += '\n';
+  }
+
+  return context;
+}
+
+function resolveSourceSelection(
+  source: ContextSource,
+  { compact = false }: SourceSelectionOptions = {}
+): SourceSelection {
+  const baseAmount = source.amount ?? source.limit;
+  const baseStrategy = source.strategy ?? (baseAmount !== undefined ? 'latest' : 'all');
+
+  if (!compact) {
+    return { amount: baseAmount, strategy: baseStrategy };
+  }
+
+  return {
+    amount: source.compactAmount ?? 1,
+    strategy: source.compactStrategy ?? (baseStrategy === 'all' ? 'latest' : baseStrategy),
+  };
+}
+
+function resolveSourceMessages({
+  source,
+  messageBus,
+  cluster,
+  lastTaskEndTime,
+  lastAgentStartTime,
+  afterId,
+  throughId,
+  triggeringMessageId,
+  compact = false,
+}: SourceMessageParams): ContextMessage[] {
+  const sinceTimestamp = resolveSourceSince(source, cluster, lastTaskEndTime, lastAgentStartTime);
+  const { amount, strategy } = resolveSourceSelection(source, { compact });
+  const messages = messageBus.query({
+    cluster_id: cluster.id,
+    topic: source.topic,
+    sender: source.sender,
+    since: sinceTimestamp,
+    afterId,
+    throughId,
+  });
+  const replayableMessages = messages.filter(
+    (message) => isReplayableMessage(message) && message.id !== triggeringMessageId
+  );
+
+  if (amount === undefined) {
+    return replayableMessages;
+  }
+
+  if (strategy === 'latest') {
+    return replayableMessages.slice(-amount);
+  }
+
+  return replayableMessages.slice(0, amount);
+}
+
+const REQUIRED_TOPICS = new Set(['STATE_SNAPSHOT', 'ISSUE_OPENED', 'PLAN_READY']);
+const HIGH_PRIORITY_TOPICS = new Set(['VALIDATION_RESULT', 'IMPLEMENTATION_READY']);
+
+function resolveSourcePriority(source: ContextSource): string {
+  if (source.priority) {
+    return source.priority;
+  }
+
+  if (REQUIRED_TOPICS.has(source.topic)) {
+    return 'required';
+  }
+
+  if (HIGH_PRIORITY_TOPICS.has(source.topic)) {
+    return 'high';
+  }
+
+  return 'medium';
+}
+
+function buildSourcePack({
+  source,
+  index,
+  messageBus,
+  cluster,
+  lastTaskEndTime,
+  lastAgentStartTime,
+  afterId,
+  throughId,
+  triggeringMessageId,
+}: SourcePackParams): SourcePack {
+  const render = (compact: boolean): string => {
+    const messages = resolveSourceMessages({
+      source,
+      messageBus,
+      cluster,
+      lastTaskEndTime,
+      lastAgentStartTime,
+      afterId,
+      throughId,
+      triggeringMessageId,
+      compact,
+    });
+
+    if (messages.length === 0) {
+      return '';
+    }
+
+    return formatSourceMessagesSection(source, messages);
+  };
+
+  return {
+    id: `source:${source.topic}:${index}`,
+    section: 'sources',
+    priority: resolveSourcePriority(source),
+    render: () => render(false),
+    compact: () => render(true),
+  };
+}
+
+export = {
+  buildSourcePack,
+};

package/src/agent/agent-context-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/agent/agent-context-types.ts

@@ -0,0 +1,132 @@
+export interface JsonSchema {
+  readonly type?: string;
+  readonly description?: string;
+  readonly enum?: readonly unknown[];
+  readonly properties?: Readonly<Record<string, JsonSchema | null | undefined>>;
+}
+
+export interface LegacyOutputFormat {
+  readonly rules?: readonly string[];
+  readonly example?: unknown;
+}
+
+export interface PromptObject {
+  readonly system?: string | null;
+  readonly outputFormat?: LegacyOutputFormat | null;
+}
+
+export interface ContextSource {
+  topic: string;
+  sender?: unknown;
+  since?: unknown;
+  amount?: number;
+  limit?: number;
+  strategy?: string;
+  compactAmount?: number;
+  compactStrategy?: string;
+  priority?: string;
+}
+
+export interface ContextStrategy {
+  maxTokens?: number;
+  sources?: ContextSource[];
+  readonly [key: string]: unknown;
+}
+
+export interface AgentContextConfig {
+  readonly prompt?: string | PromptObject | null;
+  readonly promptConfig?: {
+    readonly type?: string | null;
+  } | null;
+  readonly cwd?: string | null;
+  readonly jsonSchema?: JsonSchema | null;
+  readonly outputFormat?: string | null;
+  readonly role?: string;
+  readonly requiredQualityGates?: unknown;
+  readonly commandProofs?: unknown;
+  readonly contextStrategy?: ContextStrategy | null;
+}
+
+export interface WorktreeContext {
+  readonly enabled?: boolean;
+  readonly path?: string | null;
+}
+
+export interface IsolationContext {
+  readonly enabled?: boolean;
+}
+
+export interface ValidationCriterion {
+  readonly status?: string;
+  readonly id?: string;
+  readonly reason?: string;
+}
+
+export interface ContextMessageData {
+  readonly criteriaResults?: readonly ValidationCriterion[] | null;
+  readonly contextSafe?: unknown;
+  readonly replayPolicy?: unknown;
+  readonly [key: string]: unknown;
+}
+
+export interface ContextMessage {
+  readonly id?: unknown;
+  readonly topic?: unknown;
+  readonly timestamp: string | number;
+  readonly sender: string;
+  readonly metadata?: ContextMessageData | null;
+  readonly content?: {
+    readonly text?: string | null;
+    readonly data?: ContextMessageData | null;
+  } | null;
+}
+
+export interface ContextQuery {
+  cluster_id: string;
+  topic: string;
+  sender?: unknown;
+  since?: unknown;
+  afterId?: unknown;
+  throughId?: unknown;
+  limit?: number;
+}
+
+export interface ContextMessageBus {
+  query(criteria: ContextQuery): ContextMessage[];
+  publish(message: unknown): unknown;
+}
+
+export interface ContextCluster {
+  id: string;
+  createdAt: number;
+}
+
+export interface TriggeringMessage {
+  id?: unknown;
+  topic: string;
+  sender: string;
+  content?: {
+    text?: string | null;
+  } | null;
+}
+
+export interface BuildContextParams {
+  id: string;
+  role: string;
+  iteration: number;
+  config: AgentContextConfig;
+  messageBus: ContextMessageBus;
+  cluster: ContextCluster;
+  triggeringMessage: TriggeringMessage;
+  lastTaskEndTime?: number | null | undefined;
+  lastAgentStartTime?: number | null | undefined;
+  selectedPrompt?: string | null | undefined;
+  queuedGuidance?: string | null | undefined;
+  worktree?: WorktreeContext | null | undefined;
+  isolation?: IsolationContext | null | undefined;
+  mode?: string | undefined;
+  continuationSequence?: unknown;
+  contextThroughId?: unknown;
+  previousPromptIdentity?: unknown;
+  currentPromptIdentity?: unknown;
+}

package/src/agent/agent-context-validation-sections.js

@@ -0,0 +1,73 @@
+"use strict";
+const validationPlatform = require("./validation-platform");
+const { isPlatformMismatchReason } = validationPlatform;
+function shouldKeepCannotValidate(criteria, ignoreReason, seenIds) {
+    if (criteria.status !== 'CANNOT_VALIDATE' || !criteria.id) {
+        return false;
+    }
+    if (ignoreReason && ignoreReason(criteria.reason)) {
+        return false;
+    }
+    if (seenIds.has(criteria.id)) {
+        return false;
+    }
+    return true;
+}
+function isValidationCriteria(value) {
+    return Array.isArray(value);
+}
+function collectCannotValidateCriteria(prevValidations, options = {}) {
+    const cannotValidateCriteria = [];
+    const seenIds = new Set();
+    const ignoreReason = options.ignoreReason;
+    for (const msg of prevValidations) {
+        const criteriaResults = msg.content?.data?.criteriaResults;
+        if (!isValidationCriteria(criteriaResults)) {
+            continue;
+        }
+        for (const criteria of criteriaResults) {
+            if (!shouldKeepCannotValidate(criteria, ignoreReason, seenIds)) {
+                continue;
+            }
+            seenIds.add(criteria.id);
+            cannotValidateCriteria.push({
+                id: criteria.id,
+                reason: criteria.reason || 'No reason provided',
+            });
+        }
+    }
+    return cannotValidateCriteria;
+}
+function buildCannotValidateSection(cannotValidateCriteria) {
+    if (cannotValidateCriteria.length === 0) {
+        return '';
+    }
+    return [
+        '',
+        '## ⚠️ Permanently Unverifiable Criteria (SKIP THESE)',
+        '',
+        'The following criteria have PERMANENT environmental limitations (missing tools, no access).',
+        'These limitations have not changed. Do NOT re-attempt verification.',
+        'Mark these as CANNOT_VALIDATE again with the same reason.',
+        '',
+        ...cannotValidateCriteria.map((criteria) => `- **${criteria.id}**: ${criteria.reason}`),
+        '',
+    ].join('\n');
+}
+function buildValidatorSkipSection({ role, messageBus, cluster, isolation, }) {
+    if (role !== 'validator') {
+        return '';
+    }
+    const prevValidations = messageBus.query({
+        cluster_id: cluster.id,
+        topic: 'VALIDATION_RESULT',
+        since: cluster.createdAt,
+        limit: 50,
+    });
+    const ignoreReason = isolation?.enabled ? isPlatformMismatchReason : null;
+    const cannotValidateCriteria = collectCannotValidateCriteria(prevValidations, { ignoreReason });
+    return buildCannotValidateSection(cannotValidateCriteria);
+}
+module.exports = {
+    buildValidatorSkipSection,
+};

package/src/agent/agent-context-validation-sections.ts

@@ -0,0 +1,129 @@
+import validationPlatform = require('./validation-platform');
+
+import type {
+  ContextCluster,
+  ContextMessage,
+  ContextMessageBus,
+  IsolationContext,
+  ValidationCriterion,
+} from './agent-context-types';
+
+interface CannotValidateCriterion {
+  id: string;
+  reason: string;
+}
+
+interface CannotValidateOptions {
+  ignoreReason?: ((reason: string | undefined) => boolean) | null;
+}
+
+interface ValidatorSkipParams {
+  role: string;
+  messageBus: ContextMessageBus;
+  cluster: ContextCluster;
+  isolation?: IsolationContext | null | undefined;
+}
+
+const { isPlatformMismatchReason } = validationPlatform;
+
+function shouldKeepCannotValidate(
+  criteria: ValidationCriterion,
+  ignoreReason: CannotValidateOptions['ignoreReason'],
+  seenIds: ReadonlySet<string>
+): criteria is ValidationCriterion & { id: string } {
+  if (criteria.status !== 'CANNOT_VALIDATE' || !criteria.id) {
+    return false;
+  }
+
+  if (ignoreReason && ignoreReason(criteria.reason)) {
+    return false;
+  }
+
+  if (seenIds.has(criteria.id)) {
+    return false;
+  }
+
+  return true;
+}
+
+function isValidationCriteria(
+  value: readonly ValidationCriterion[] | null | undefined
+): value is readonly ValidationCriterion[] {
+  return Array.isArray(value);
+}
+
+function collectCannotValidateCriteria(
+  prevValidations: readonly ContextMessage[],
+  options: CannotValidateOptions = {}
+): CannotValidateCriterion[] {
+  const cannotValidateCriteria: CannotValidateCriterion[] = [];
+  const seenIds = new Set<string>();
+  const ignoreReason = options.ignoreReason;
+
+  for (const msg of prevValidations) {
+    const criteriaResults = msg.content?.data?.criteriaResults;
+    if (!isValidationCriteria(criteriaResults)) {
+      continue;
+    }
+
+    for (const criteria of criteriaResults) {
+      if (!shouldKeepCannotValidate(criteria, ignoreReason, seenIds)) {
+        continue;
+      }
+
+      seenIds.add(criteria.id);
+      cannotValidateCriteria.push({
+        id: criteria.id,
+        reason: criteria.reason || 'No reason provided',
+      });
+    }
+  }
+
+  return cannotValidateCriteria;
+}
+
+function buildCannotValidateSection(
+  cannotValidateCriteria: readonly CannotValidateCriterion[]
+): string {
+  if (cannotValidateCriteria.length === 0) {
+    return '';
+  }
+
+  return [
+    '',
+    '## ⚠️ Permanently Unverifiable Criteria (SKIP THESE)',
+    '',
+    'The following criteria have PERMANENT environmental limitations (missing tools, no access).',
+    'These limitations have not changed. Do NOT re-attempt verification.',
+    'Mark these as CANNOT_VALIDATE again with the same reason.',
+    '',
+    ...cannotValidateCriteria.map((criteria) => `- **${criteria.id}**: ${criteria.reason}`),
+    '',
+  ].join('\n');
+}
+
+function buildValidatorSkipSection({
+  role,
+  messageBus,
+  cluster,
+  isolation,
+}: ValidatorSkipParams): string {
+  if (role !== 'validator') {
+    return '';
+  }
+
+  const prevValidations = messageBus.query({
+    cluster_id: cluster.id,
+    topic: 'VALIDATION_RESULT',
+    since: cluster.createdAt,
+    limit: 50,
+  });
+  const ignoreReason = isolation?.enabled ? isPlatformMismatchReason : null;
+  const cannotValidateCriteria = collectCannotValidateCriteria(prevValidations, { ignoreReason });
+
+  return buildCannotValidateSection(cannotValidateCriteria);
+}
+
+export = {
+  buildValidatorSkipSection,
+};