🏷️ fix: Keep Redacted Child Labels in Activity Phase Prompts

src/langfuseToolOutputTracing.ts

@@ -157,6 +157,37 @@ function toolNameMatches(
 /** Whether a tool's outputs are excluded from tracing (global disable or
  *  `redactedToolNames` match). Exported for the activity-label prompt
  *  builder, whose prompt becomes Langfuse generation input. */
+/**
+ * Whether `candidate` redacts at least every tool output `required` redacts:
+ * text produced under `candidate` cannot carry output `required` hides.
+ */
+export function coversToolOutputRedaction(
+  candidate: ResolvedLangfuseToolOutputTracingConfig | undefined,
+  required: ResolvedLangfuseToolOutputTracingConfig
+): boolean {
+  if (candidate == null) {
+    return false;
+  }
+  if (candidate.enabled === false) {
+    return true;
+  }
+  if (required.enabled === false) {
+    return false;
+  }
+  if (
+    required.redactedToolNameMatchMode === 'partial' &&
+    candidate.redactedToolNameMatchMode !== 'partial'
+  ) {
+    return false;
+  }
+  for (const toolName of required.redactedToolNames) {
+    if (!candidate.redactedToolNames.has(toolName)) {
+      return false;
+    }
+  }
+  return true;
+}
+
 export function shouldRedactTool(
   toolName: string | undefined,
   config: ResolvedLangfuseToolOutputTracingConfig

src/prompts/activityLabel.ts

@@ -277,6 +277,11 @@ export type BuildActivityPhaseLabelPromptParams = {
   charLimit: number;
   assistantContext?: string[];
   redaction?: ResolvedLangfuseToolOutputTracingConfig;
+  /**
+   * Every child label was generated under a policy covering `redaction`, so
+   * labels stay usable while reasoning and commentary remain suppressed.
+   */
+  childLabelsRedacted?: boolean;
 };
 
 /**
@@ -290,10 +295,12 @@ export function buildActivityPhaseLabelPrompt({
   charLimit,
   assistantContext,
   redaction,
+  childLabelsRedacted = false,
 }: BuildActivityPhaseLabelPromptParams): string {
   const freeFormSuppressed =
     redaction != null &&
     (redaction.enabled === false || redaction.redactedToolNames.size > 0);
+  const labelsAllowed = !freeFormSuppressed || childLabelsRedacted;
   const sections: string[] = [];
   if (
     !freeFormSuppressed &&
@@ -325,7 +332,7 @@ export function buildActivityPhaseLabelPrompt({
         status = 'partial';
       }
       if (
-        !freeFormSuppressed &&
+        labelsAllowed &&
         activity.label != null &&
         activity.label.trim() !== ''
       ) {

src/run.ts

@@ -74,6 +74,7 @@ import {
   resolveLangfuseConfig,
   resolveToolOutputTracingConfig,
 } from '@/langfuseConfig';
+import { coversToolOutputRedaction } from '@/langfuseToolOutputTracing';
 import {
   cloneToolApprovalInterruptPayload,
   TOOL_APPROVAL_REVIEW_CONFIG_KEY,
@@ -3179,13 +3180,28 @@ export class Run<_T extends t.BaseGraphState> {
         redactionText: redaction.redactionText,
       };
     }
+    /** Child labels were generated from each agent's own redacted evidence,
+     *  so they can stand in for that evidence only when every agent's policy
+     *  covers the merged phase policy. */
+    const childLabelsRedacted =
+      redaction != null &&
+      redactionContexts.length > 0 &&
+      redactionContexts.every((context) =>
+        coversToolOutputRedaction(
+          hasToolOutputTracingConfig(this.langfuse, context.langfuse)
+            ? resolveToolOutputTracingConfig(this.langfuse, context.langfuse)
+            : undefined,
+          redaction
+        )
+      );
 
     const userPrompt = buildActivityPhaseLabelPrompt({
       activities,
       totalActivityCount,
       charLimit,
       assistantContext,
       redaction,
+      childLabelsRedacted,
     });
     if (userPrompt === '') {
       return {};

src/specs/activity-label-prompt.test.ts

@@ -1,11 +1,15 @@
 import type { ActivityLabelToolEntry } from '@/types/activityLabel';
+import type { LangfuseToolOutputTracingConfig } from '@/types/graph';
 import {
   ACTIVITY_PHASE_PROMPT_MAX_LENGTH,
   buildActivityLabelPrompt,
   buildActivityPhaseLabelPrompt,
   normalizeActivityPhaseLabel,
 } from '@/prompts/activityLabel';
-import { LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT } from '@/langfuseToolOutputTracing';
+import {
+  coversToolOutputRedaction,
+  LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT,
+} from '@/langfuseToolOutputTracing';
 import { resolveToolOutputTracingConfig } from '@/langfuseConfig';
 
 const entries: ActivityLabelToolEntry[] = [
@@ -356,4 +360,110 @@ describe('buildActivityPhaseLabelPrompt', () => {
     );
     expect(normalizeActivityPhaseLabel('x'.repeat(300))).toHaveLength(160);
   });
+
+  it('keeps committed labels but not reasoning or commentary when child labels are redacted', () => {
+    const redaction = resolveToolOutputTracingConfig({
+      toolOutputTracing: { redactedToolNames: ['db_query'] },
+    });
+    const prompt = buildActivityPhaseLabelPrompt({
+      activities: [
+        { label: 'Counted open incidents' },
+        {
+          label: 'Grouped incidents by service',
+          thinkingExcerpts: ['REASONING_MAY_QUOTE_REDACTED_OUTPUT'],
+        },
+      ],
+      charLimit: 600,
+      assistantContext: ['COMMENTARY_MAY_QUOTE_REDACTED_OUTPUT'],
+      redaction,
+      childLabelsRedacted: true,
+    });
+    expect(prompt).toContain('Counted open incidents');
+    expect(prompt).toContain('Grouped incidents by service');
+    expect(prompt).not.toContain('REASONING_MAY_QUOTE_REDACTED_OUTPUT');
+    expect(prompt).not.toContain('COMMENTARY_MAY_QUOTE_REDACTED_OUTPUT');
+  });
+
+  it('drops committed labels under an active policy unless child labels are redacted', () => {
+    const redaction = resolveToolOutputTracingConfig({
+      toolOutputTracing: { redactedToolNames: ['db_query'] },
+    });
+    expect(
+      buildActivityPhaseLabelPrompt({
+        activities: [
+          { label: 'Counted open incidents' },
+          { label: 'Grouped by service' },
+        ],
+        charLimit: 600,
+        redaction,
+      })
+    ).toBe('');
+  });
+});
+
+describe('coversToolOutputRedaction', () => {
+  const policy = (toolOutputTracing: LangfuseToolOutputTracingConfig) =>
+    resolveToolOutputTracingConfig({ toolOutputTracing });
+
+  it('treats a missing candidate policy as not covering', () => {
+    expect(
+      coversToolOutputRedaction(undefined, policy({ redactedToolNames: ['a'] }))
+    ).toBe(false);
+  });
+
+  it('covers when the candidate redacts every tool output', () => {
+    expect(
+      coversToolOutputRedaction(
+        policy({ enabled: false }),
+        policy({ redactedToolNames: ['a'] })
+      )
+    ).toBe(true);
+  });
+
+  it('does not cover a globally disabled requirement with a named list', () => {
+    expect(
+      coversToolOutputRedaction(
+        policy({ redactedToolNames: ['a'] }),
+        policy({ enabled: false })
+      )
+    ).toBe(false);
+  });
+
+  it('requires every required tool name', () => {
+    const required = policy({ redactedToolNames: ['a', 'b'] });
+    expect(
+      coversToolOutputRedaction(
+        policy({ redactedToolNames: ['a', 'b', 'c'] }),
+        required
+      )
+    ).toBe(true);
+    expect(
+      coversToolOutputRedaction(policy({ redactedToolNames: ['a'] }), required)
+    ).toBe(false);
+  });
+
+  it('does not let exact matching cover a partial requirement', () => {
+    const required = policy({
+      redactedToolNames: ['a'],
+      redactedToolNameMatchMode: 'partial',
+    });
+    expect(
+      coversToolOutputRedaction(
+        policy({
+          redactedToolNames: ['a'],
+          redactedToolNameMatchMode: 'exact',
+        }),
+        required
+      )
+    ).toBe(false);
+    expect(
+      coversToolOutputRedaction(
+        policy({
+          redactedToolNames: ['a'],
+          redactedToolNameMatchMode: 'partial',
+        }),
+        required
+      )
+    ).toBe(true);
+  });
 });

src/specs/activity-phase-label.test.ts

@@ -303,4 +303,86 @@ describe('generateActivityPhaseLabel', () => {
     expect(String(messages[1].content)).not.toContain('OMITTED_AGENT_SECRET');
     expect(String(messages[1].content)).toContain('public-one');
   });
+
+  it('keeps child labels when every agent shares the redaction policy', async () => {
+    const run = await Run.create({
+      runId: 'uniform-policy-phase-run',
+      graphConfig: {
+        type: 'standard',
+        agents: [
+          {
+            agentId: 'agent-1',
+            provider: Providers.OPENAI,
+            clientOptions: { model: 'gpt-4.1-mini' },
+            tools: [],
+          },
+        ],
+      },
+      langfuse: {
+        toolOutputTracing: {
+          redactedToolNames: ['run_select_query'],
+          redactedToolNameMatchMode: 'partial',
+        },
+      },
+    });
+
+    await expect(
+      run.generateActivityPhaseLabel({
+        provider: Providers.OPENAI,
+        activities: [
+          { agentId: 'agent-1', label: 'Listed the orders tables' },
+          { agentId: 'agent-1', label: 'Measured daily order volume' },
+        ],
+        assistantContext: ['COMMENTARY_MAY_QUOTE_REDACTED_OUTPUT'],
+      })
+    ).resolves.toEqual({
+      label: 'Fixed session refresh handling and verified auth tests',
+    });
+
+    const prompt = String((invoke.mock.calls[0][0] as AIMessage[])[1].content);
+    expect(prompt).toContain('Listed the orders tables');
+    expect(prompt).toContain('Measured daily order volume');
+    expect(prompt).not.toContain('COMMENTARY_MAY_QUOTE_REDACTED_OUTPUT');
+  });
+
+  it('suppresses child labels when a contributing agent has a weaker policy', async () => {
+    const run = await Run.create({
+      runId: 'weaker-overlay-phase-run',
+      graphConfig: {
+        type: 'multi-agent',
+        agents: [
+          {
+            agentId: 'agent-1',
+            provider: Providers.OPENAI,
+            clientOptions: { model: 'gpt-4.1-mini' },
+            tools: [],
+          },
+          {
+            agentId: 'agent-2',
+            provider: Providers.OPENAI,
+            clientOptions: { model: 'gpt-4.1-mini' },
+            tools: [],
+            langfuse: {
+              toolOutputTracing: { redactedToolNames: ['secret_tool'] },
+            },
+          },
+        ],
+        edges: [],
+      },
+    });
+
+    await expect(
+      run.generateActivityPhaseLabel({
+        provider: Providers.OPENAI,
+        activities: [
+          {
+            agentId: 'agent-1',
+            label: 'Read WEAKER_AGENT_SECRET from secret_tool',
+          },
+          { agentId: 'agent-2', label: 'Checked the strict agent state' },
+        ],
+      })
+    ).resolves.toEqual({});
+    expect(invoke).not.toHaveBeenCalled();
+  });
 });