@pixelbyte-software/pixcode 1.42.0 → 1.42.2

package/scripts/smoke/context-packet.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+
+function read(relativePath) {
+  return fs.readFileSync(path.join(root, relativePath), 'utf8');
+}
+
+const contextSource = read('server/modules/orchestration/workflows/context-packet.ts');
+assert.match(contextSource, /PIXCODE_CONTEXT_PROTOCOL/, 'Context packets should declare a stable protocol id.');
+assert.match(contextSource, /pixcode\.context\.v1/, 'Context packets should use the v1 protocol id.');
+assert.match(contextSource, /originalUserRequest/, 'Context packets should preserve the original user request.');
+assert.match(contextSource, /project/, 'Context packets should include project metadata.');
+assert.match(contextSource, /task/, 'Context packets should include task metadata.');
+assert.match(contextSource, /constraints/, 'Context packets should include execution constraints.');
+assert.match(contextSource, /upstreamArtifacts/, 'Context packets should include upstream artifact context.');
+assert.match(contextSource, /runState/, 'Context packets should include current run state.');
+assert.match(contextSource, /compaction/, 'Context packets should expose compaction metadata.');
+assert.match(contextSource, /formatContextPacketForPrompt/, 'Context packets should be formatted for prompts.');
+
+const types = read('server/modules/orchestration/workflows/workflow.types.ts');
+assert.match(types, /WorkflowContextPacket/, 'Workflow types should expose context packets.');
+assert.match(types, /contextPacket\?: WorkflowContextPacket/, 'Node runs should persist context packets.');
+
+const runner = read('server/modules/orchestration/workflows/workflow-runner.ts');
+assert.match(runner, /buildWorkflowContextPacket/, 'Workflow runner should build context packets.');
+assert.match(runner, /formatContextPacketForPrompt/, 'Workflow runner should inject context packets into prompts.');
+assert.ok(
+  runner.indexOf('Original user request') < runner.indexOf('formatContextPacketForPrompt(contextPacket)')
+    && runner.indexOf('formatContextPacketForPrompt(contextPacket)') < runner.indexOf('workspaceContextPrompt(workspaceTarget)'),
+  'Original request must stay before structured context, and workspace context must remain derived context.',
+);
+
+const trace = read('server/modules/orchestration/workflows/workflow-trace.ts');
+assert.match(trace, /contextPacket/, 'Workflow trace should surface context packet metadata.');
+assert.match(trace, /workflow\.trace\.contextPacket/, 'Workflow trace should label context packet events.');
+assert.match(trace, /compaction/, 'Workflow trace should include context compaction metadata.');
+
+console.log('context packet smoke passed');

package/scripts/smoke/workflow-fallback-replay.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+
+function read(relativePath) {
+  return fs.readFileSync(path.join(root, relativePath), 'utf8');
+}
+
+const fallbackPolicy = read('server/modules/orchestration/workflows/workflow-fallback-policy.ts');
+assert.match(fallbackPolicy, /PIXCODE_FALLBACK_POLICY_PROTOCOL/, 'Fallback policy should declare a stable protocol id.');
+assert.match(fallbackPolicy, /pixcode\.fallback-policy\.v1/, 'Fallback policy should use the v1 protocol id.');
+assert.match(fallbackPolicy, /provider_failure/, 'Fallback policy should classify provider failures.');
+assert.match(fallbackPolicy, /timeout/, 'Fallback policy should classify timeouts.');
+assert.match(fallbackPolicy, /tool_failure/, 'Fallback policy should classify tool failures.');
+assert.match(fallbackPolicy, /invalid_output/, 'Fallback policy should classify invalid output.');
+assert.match(fallbackPolicy, /resolveWorkflowFallbackDecision/, 'Fallback policy should expose a decision helper.');
+
+const replay = read('server/modules/orchestration/workflows/workflow-replay.ts');
+assert.match(replay, /PIXCODE_REPLAY_PROTOCOL/, 'Replay support should declare a stable protocol id.');
+assert.match(replay, /pixcode\.workflow-replay\.v1/, 'Replay support should use the v1 protocol id.');
+assert.match(replay, /buildWorkflowReplayPlan/, 'Replay support should build a replay plan from stored run data.');
+assert.match(replay, /requiresApproval/, 'Replay plans should expose approval requirements.');
+assert.match(replay, /file-write/, 'Replay safety should detect file-write actions.');
+assert.match(replay, /shell/, 'Replay safety should detect shell actions.');
+assert.match(replay, /network/, 'Replay safety should detect network actions.');
+
+const runner = read('server/modules/orchestration/workflows/workflow-runner.ts');
+assert.match(runner, /resolveWorkflowFallbackDecision/, 'Workflow runner should use policy-driven fallback decisions.');
+assert.match(runner, /fallbackTrigger/, 'Fallback nodes should record the trigger that launched them.');
+assert.match(runner, /fallbackSkippedEvents/, 'Skipped fallback decisions should be recorded.');
+
+const trace = read('server/modules/orchestration/workflows/workflow-trace.ts');
+assert.match(trace, /workflow\.trace\.fallback/, 'Trace timeline should surface fallback events.');
+assert.match(trace, /workflow\.trace\.replay/, 'Trace timeline should surface replay metadata.');
+
+const routes = read('server/modules/orchestration/workflows/workflow.routes.ts');
+assert.match(routes, /replay-plan/, 'Workflow routes should expose a replay plan endpoint.');
+assert.match(routes, /REPLAY_APPROVAL_REQUIRED/, 'Replay route should require approval before unsafe replay.');
+assert.match(routes, /workflowRunner\.start\(\s*replayPlan\.workflow/s, 'Replay route should start from the generated replay workflow.');
+
+const panel = read('src/components/orchestration/workflows/WorkflowRunPanel.tsx');
+assert.match(panel, /loadReplayPlan/, 'Workflow run panel should load replay plans.');
+assert.match(panel, /replayRun/, 'Workflow run panel should expose a replay action.');
+assert.match(panel, /approveReplay/, 'Workflow run panel should expose explicit approval for guarded replay.');
+assert.match(panel, /orchestration\.replayRun/, 'Workflow UI should render replay labels.');
+
+const en = read('src/i18n/locales/en/common.json');
+const tr = read('src/i18n/locales/tr/common.json');
+assert.match(en, /"replayRun"/, 'English replay translation is missing.');
+assert.match(tr, /"replayRun"/, 'Turkish replay translation is missing.');
+
+console.log('workflow fallback replay smoke passed');

package/server/modules/orchestration/workflows/context-packet.ts

@@ -0,0 +1,186 @@
+import type { ResolvedWorkspaceTarget } from '@/modules/orchestration/workflows/workspace-target.js';
+
+export const PIXCODE_CONTEXT_PROTOCOL = 'pixcode.context.v1' as const;
+export const MAX_CONTEXT_PACKET_TEXT_CHARS = 16_000;
+
+export interface WorkflowContextPacket {
+  protocol: typeof PIXCODE_CONTEXT_PROTOCOL;
+  originalUserRequest: string;
+  project: {
+    kind: string;
+    label: string;
+    selectedProjectName?: string;
+  };
+  task: {
+    workflowId: string;
+    workflowRunId: string;
+    nodeId: string;
+    stage?: string;
+    assignment?: string;
+    stepInstructions: string;
+  };
+  constraints: {
+    adapterId?: string;
+    agentLabel?: string;
+    model?: string;
+    permissionMode?: string;
+    isolation?: string;
+    toolsSettings?: Record<string, unknown>;
+  };
+  upstreamArtifacts: Array<{
+    type: 'upstream-context';
+    text: string;
+    sourceNodeIds: string[];
+  }>;
+  runState: {
+    status: string;
+    startedAt: number;
+    nodeCount: number;
+    completedNodeIds: string[];
+    runningNodeIds: string[];
+  };
+  compaction: {
+    maxChars: number;
+    originalChars: number;
+    compactedChars: number;
+    omittedChars: number;
+    wasCompacted: boolean;
+  };
+  createdAt: string;
+}
+
+type ContextPacketRun = {
+  id: string;
+  workflowId: string;
+  status: string;
+  input?: string;
+  startedAt: number;
+  nodeRuns: Array<{
+    nodeId: string;
+    status: string;
+  }>;
+};
+
+type ContextPacketNode = {
+  id: string;
+  adapterId?: string;
+  agentLabel?: string;
+  assignment?: string;
+  prompt: string;
+  stage?: string;
+  model?: string;
+  permissionMode?: string;
+  toolsSettings?: Record<string, unknown>;
+  isolation?: string;
+};
+
+export type BuildWorkflowContextPacketInput = {
+  run: ContextPacketRun;
+  node: ContextPacketNode;
+  workspaceTarget: ResolvedWorkspaceTarget;
+  inputContext: string;
+  inputNodeIds: string[];
+};
+
+function compactContextText(text: string): {
+  text: string;
+  originalChars: number;
+  compactedChars: number;
+  omittedChars: number;
+  wasCompacted: boolean;
+} {
+  const originalChars = text.length;
+  if (originalChars <= MAX_CONTEXT_PACKET_TEXT_CHARS) {
+    return {
+      text,
+      originalChars,
+      compactedChars: originalChars,
+      omittedChars: 0,
+      wasCompacted: false,
+    };
+  }
+
+  const edge = Math.floor(MAX_CONTEXT_PACKET_TEXT_CHARS / 2);
+  const omittedChars = originalChars - MAX_CONTEXT_PACKET_TEXT_CHARS;
+  const compacted = [
+    text.slice(0, edge),
+    `\n\n[...${omittedChars} characters omitted from upstream context packet...]\n\n`,
+    text.slice(-edge),
+  ].join('');
+
+  return {
+    text: compacted,
+    originalChars,
+    compactedChars: compacted.length,
+    omittedChars,
+    wasCompacted: true,
+  };
+}
+
+export function buildWorkflowContextPacket({
+  run,
+  node,
+  workspaceTarget,
+  inputContext,
+  inputNodeIds,
+}: BuildWorkflowContextPacketInput): WorkflowContextPacket {
+  const compacted = compactContextText(inputContext);
+  return {
+    protocol: PIXCODE_CONTEXT_PROTOCOL,
+    originalUserRequest: run.input?.trim() || '(No original user request was provided.)',
+    project: {
+      kind: workspaceTarget.kind,
+      label: workspaceTarget.label,
+      selectedProjectName: workspaceTarget.selectedProjectName,
+    },
+    task: {
+      workflowId: run.workflowId,
+      workflowRunId: run.id,
+      nodeId: node.id,
+      stage: node.stage,
+      assignment: node.assignment,
+      stepInstructions: node.prompt,
+    },
+    constraints: {
+      adapterId: node.adapterId,
+      agentLabel: node.agentLabel,
+      model: node.model,
+      permissionMode: node.permissionMode,
+      isolation: node.isolation,
+      toolsSettings: node.toolsSettings,
+    },
+    upstreamArtifacts: compacted.text
+      ? [{
+        type: 'upstream-context',
+        text: compacted.text,
+        sourceNodeIds: inputNodeIds,
+      }]
+      : [],
+    runState: {
+      status: run.status,
+      startedAt: run.startedAt,
+      nodeCount: run.nodeRuns.length,
+      completedNodeIds: run.nodeRuns
+        .filter((nodeRun) => nodeRun.status === 'completed')
+        .map((nodeRun) => nodeRun.nodeId),
+      runningNodeIds: run.nodeRuns
+        .filter((nodeRun) => nodeRun.status === 'running')
+        .map((nodeRun) => nodeRun.nodeId),
+    },
+    compaction: {
+      maxChars: MAX_CONTEXT_PACKET_TEXT_CHARS,
+      originalChars: compacted.originalChars,
+      compactedChars: compacted.compactedChars,
+      omittedChars: compacted.omittedChars,
+      wasCompacted: compacted.wasCompacted,
+    },
+    createdAt: new Date().toISOString(),
+  };
+}
+
+export function formatContextPacketForPrompt(packet: WorkflowContextPacket): string {
+  return [
+    `Pixcode standardized init context packet (${PIXCODE_CONTEXT_PROTOCOL}):`,
+    JSON.stringify(packet, null, 2),
+  ].join('\n');
+}

package/server/modules/orchestration/workflows/workflow-fallback-policy.ts

@@ -0,0 +1,161 @@
+import type { WorkflowNode, WorkflowRun } from '@/modules/orchestration/workflows/workflow.types.js';
+
+export const PIXCODE_FALLBACK_POLICY_PROTOCOL = 'pixcode.fallback-policy.v1';
+
+export type WorkflowFallbackTrigger = 'provider_failure' | 'timeout' | 'tool_failure' | 'invalid_output';
+
+export interface WorkflowFallbackPolicy {
+  protocol: typeof PIXCODE_FALLBACK_POLICY_PROTOCOL;
+  enabled: boolean;
+  triggers: WorkflowFallbackTrigger[];
+  maxFallbacksPerRun: number;
+  requireDifferentAgent: boolean;
+}
+
+export interface WorkflowFallbackDecision {
+  shouldFallback: boolean;
+  trigger: WorkflowFallbackTrigger;
+  reason: string;
+  policy: WorkflowFallbackPolicy;
+  skippedReason?: string;
+}
+
+const DEFAULT_TRIGGERS: WorkflowFallbackTrigger[] = [
+  'provider_failure',
+  'timeout',
+  'tool_failure',
+  'invalid_output',
+];
+
+export const DEFAULT_WORKFLOW_FALLBACK_POLICY: WorkflowFallbackPolicy = {
+  protocol: PIXCODE_FALLBACK_POLICY_PROTOCOL,
+  enabled: true,
+  triggers: DEFAULT_TRIGGERS,
+  maxFallbacksPerRun: 3,
+  requireDifferentAgent: true,
+};
+
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' ? value as Record<string, unknown> : undefined;
+}
+
+function readBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function readNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function isWorkflowFallbackTrigger(value: unknown): value is WorkflowFallbackTrigger {
+  return value === 'provider_failure'
+    || value === 'timeout'
+    || value === 'tool_failure'
+    || value === 'invalid_output';
+}
+
+function readFallbackTriggers(value: unknown): WorkflowFallbackTrigger[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const triggers = value.filter(isWorkflowFallbackTrigger);
+  return triggers.length > 0 ? [...new Set(triggers)] : undefined;
+}
+
+export function readWorkflowFallbackPolicy(metadata?: Record<string, unknown>): WorkflowFallbackPolicy {
+  const settings = readRecord(metadata?.settings) ?? {};
+  const configured = readRecord(settings.fallbackPolicy) ?? {};
+  const maxFallbacksPerRun = readNumber(configured.maxFallbacksPerRun);
+
+  return {
+    protocol: PIXCODE_FALLBACK_POLICY_PROTOCOL,
+    enabled: readBoolean(configured.enabled) ?? DEFAULT_WORKFLOW_FALLBACK_POLICY.enabled,
+    triggers: readFallbackTriggers(configured.triggers) ?? DEFAULT_WORKFLOW_FALLBACK_POLICY.triggers,
+    maxFallbacksPerRun: maxFallbacksPerRun === undefined
+      ? DEFAULT_WORKFLOW_FALLBACK_POLICY.maxFallbacksPerRun
+      : Math.max(0, Math.min(8, Math.round(maxFallbacksPerRun))),
+    requireDifferentAgent: readBoolean(configured.requireDifferentAgent)
+      ?? DEFAULT_WORKFLOW_FALLBACK_POLICY.requireDifferentAgent,
+  };
+}
+
+export function classifyWorkflowFailure(
+  reason: string,
+  explicitTrigger?: WorkflowFallbackTrigger,
+): WorkflowFallbackTrigger {
+  if (explicitTrigger) return explicitTrigger;
+
+  const text = reason.toLocaleLowerCase('en');
+  if (/timed out|timeout|deadline/u.test(text)) return 'timeout';
+  if (/invalid (handoff|output|artifact|json|schema)|parse|protocol/u.test(text)) return 'invalid_output';
+  if (
+    /tool|command|shell|exit code|permission|file write|write failed|network|fetch|curl|wget|gh |npm |git /u
+      .test(text)
+  ) {
+    return 'tool_failure';
+  }
+  return 'provider_failure';
+}
+
+function fallbackEventCount(run: WorkflowRun): number {
+  return Array.isArray(run.metadata?.fallbackEvents) ? run.metadata.fallbackEvents.length : 0;
+}
+
+export function resolveWorkflowFallbackDecision({
+  run,
+  node,
+  reason,
+  trigger,
+  fallbackAgentInstanceId,
+}: {
+  run: WorkflowRun;
+  node: WorkflowNode;
+  reason: string;
+  trigger?: WorkflowFallbackTrigger;
+  fallbackAgentInstanceId?: string;
+}): WorkflowFallbackDecision {
+  const fallbackTrigger = classifyWorkflowFailure(reason, trigger);
+  const policy = readWorkflowFallbackPolicy(run.metadata);
+
+  if (!policy.enabled) {
+    return {
+      shouldFallback: false,
+      trigger: fallbackTrigger,
+      reason,
+      policy,
+      skippedReason: 'Fallback policy is disabled.',
+    };
+  }
+  if (!policy.triggers.includes(fallbackTrigger)) {
+    return {
+      shouldFallback: false,
+      trigger: fallbackTrigger,
+      reason,
+      policy,
+      skippedReason: `Fallback trigger ${fallbackTrigger} is not enabled.`,
+    };
+  }
+  if (fallbackEventCount(run) >= policy.maxFallbacksPerRun) {
+    return {
+      shouldFallback: false,
+      trigger: fallbackTrigger,
+      reason,
+      policy,
+      skippedReason: `Fallback limit ${policy.maxFallbacksPerRun} reached.`,
+    };
+  }
+  if (policy.requireDifferentAgent && fallbackAgentInstanceId && fallbackAgentInstanceId === node.agentInstanceId) {
+    return {
+      shouldFallback: false,
+      trigger: fallbackTrigger,
+      reason,
+      policy,
+      skippedReason: 'Fallback agent must be different from the failed agent.',
+    };
+  }
+
+  return {
+    shouldFallback: true,
+    trigger: fallbackTrigger,
+    reason,
+    policy,
+  };
+}