interface Signal {
  id: string;           // Unique identifier ("sig_abc123")
  name: string;         // Signal name ("analysis:complete")
  payload: unknown;     // Signal-specific data
  timestamp: string;    // ISO timestamp
  source?: {
    agent?: string;     // Emitting agent
    parent?: string;    // Parent signal ID (causality)
  };
}

"sig_abc123def456"

// workflow:start
{ state: TState; agents: string[] }

// workflow:end
{
  state: TState;
  metrics: { durationMs: number; activations: number };
  terminatedEarly: boolean;
}

// agent:activated
{ agent: string; triggeredBy: string }

// agent:skipped
{ agent: string; reason: string }

// agent:completed
{ agent: string; output: unknown }

// harness:start
{ model: string }

// harness:end
{
  usage?: { inputTokens: number; outputTokens: number };
  cost?: number;
  sessionId?: string;
}

// harness:error
{ error: string; retryAfter?: number }

// text:delta
{ content: string }

// text:complete
{ content: string }

// thinking:delta
{ content: string }

// thinking:complete
{ content: string }

// tool:call
{ id: string; name: string; input: unknown }

// tool:result
{ id: string; name: string; output: unknown; error?: string }

// state:{key}:changed
{ value: unknown; previousValue: unknown }

{
  name: "analysis:complete",
  source: {
    agent: "analyzer",       // Which agent emitted
    parent: "sig_xyz789",    // Parent signal (trigger)
  },
}

const chain = result.signals.filter(s => s.source?.parent === targetId);

import { createSignal } from "@open-harness/core";

yield createSignal("harness:start", { model: "my-model" });
yield createSignal("text:delta", { content: "Hello" });
yield createSignal("harness:end", { usage: { inputTokens: 10, outputTokens: 5 } });

const agentSignals = result.signals.filter(s => s.name.startsWith("agent:"));

const textComplete = result.signals.find(s => s.name === "text:complete");
const output = textComplete?.payload.content;

const totalTokens = result.signals
  .filter(s => s.name === "harness:end")
  .reduce((sum, s) => {
    const usage = s.payload.usage || { inputTokens: 0, outputTokens: 0 };
    return sum + usage.inputTokens + usage.outputTokens;
  }, 0);

function isHarnessEnd(signal: Signal): signal is Signal & { payload: { usage: Usage } } {
  return signal.name === "harness:end";
}

const harnessEnds = result.signals.filter(isHarnessEnd);