graph TB
    subgraph L6["第六层：退役治理"]
        ALP["ALP 生命周期协议<br/>退休·归档·迁移"]
    end
    subgraph L5["第五层：可观测性"]
        OPS["AgentOps / OpenTelemetry<br/>心跳·追踪·告警"]
    end
    subgraph L4["第四层：确定性编排"]
        COND["Microsoft Conductor<br/>YAML状态机·可恢复"]
        SYMP["OpenAI Symphony<br/>Issue驱动·PR闭环"]
    end
    subgraph L3["第三层：动态生成"]
        SPAWN["AgentSpawn<br/>运行时按需生成"]
    end
    subgraph L2["第二层：执行框架"]
        AEF["AEF 状态机规范<br/>IDLE→THINK→ACT→DONE"]
        FSM["FSM/Statechart<br/>确定性状态转换"]
    end
    subgraph L1["第一层：身份定义"]
        ADL["ADL 定义语言<br/>身份·权限·能力"]
        AITLP["AITLP IETF Draft<br/>信任链·委托"]
    end

    L1 --> L2 --> L3 --> L4 --> L5 --> L6

# agent-definition.yaml
agent:
  identity:
    name: "code-reviewer"
    version: "2.1.0"
    issuer: "acme-corp"
    public_key: "sha256:abc123..."
  capabilities:
    - name: "code_review"
      tools: ["github_read", "git_diff"]
      constraints:
        max_file_size: "1MB"
        allowed_extensions: [".py", ".ts", ".go"]
  permissions:
    data_access: ["repo_readonly"]
    network: ["api.github.com"]
    execution:
      max_runtime: "300s"
      max_tokens: 50000
  lifecycle:
    ttl: "24h"
    max_instances: 5
    retirement_policy: "graceful"

sequenceDiagram
    participant User
    participant Orchestrator
    participant Worker
    participant Tool

    User->>Orchestrator: 授权(VP: 全仓库读写)
    Orchestrator->>Worker: 委托(VP: 仅src/目录只读)
    Worker->>Tool: 调用(VP: 单文件读取)
    Tool-->>Worker: 验证信任链→执行
    Worker-->>Orchestrator: 结果
    Orchestrator-->>User: 汇总

CREATED → INITIALIZED → IDLE ⇄ THINKING → EXECUTING → SUSPENDED → TERMINATED

# AEF状态转换伪代码
class AgentStateMachine:
    TRANSITIONS = {
        "CREATED→INITIALIZED": {
            "guard": lambda ctx: ctx.config_valid and ctx.identity_verified,
            "action": "load_tools",
        },
        "IDLE→THINKING": {
            "guard": lambda ctx: ctx.has_task and ctx.token_budget > 0,
            "action": "acquire_reasoning_lock",
        },
        "THINKING→EXECUTING": {
            "guard": lambda ctx: ctx.has_tool_call and ctx.tool_approved,
            "action": "start_tool_execution",
        },
        "EXECUTING→SUSPENDED": {
            "guard": lambda ctx: ctx.timeout_or_quota_exceeded,
            "action": "checkpoint_state",
        },
        "SUSPENDED→THINKING": {
            "guard": lambda ctx: ctx.resource_available,
            "action": "restore_checkpoint",
        },
        "*→TERMINATED": {
            "guard": lambda ctx: ctx.ttl_expired or ctx.task_complete,
            "action": "cleanup_resources",
        },
    }

stateDiagram-v2
    [*] --> Created
    Created --> Active: initialize
    state Active {
        [*] --> Idle
        Idle --> Planning: receive_task
        Planning --> Executing: plan_approved
        Executing --> Reviewing: execution_done
        Reviewing --> Idle: approved
        Reviewing --> Planning: revision_needed
    }
    Active --> Suspended: quota_exceeded
    Suspended --> Active: quota_restored
    Active --> Terminated: task_complete OR ttl_expired
    Terminated --> [*]

# AgentSpawn 动态生成伪代码
class AgentSpawner:
    def evaluate_spawn_need(self, task_context):
        """评估是否需要spawn新Agent"""
        current_expertise = self.registry.get_capabilities()
        task_requirements = self.analyze_requirements(task_context)

        gap = task_requirements - current_expertise
        if gap.severity > SPAWN_THRESHOLD:
            new_agent_spec = self.design_agent(gap)
            return self.spawn(new_agent_spec)
        return None

    def spawn(self, spec):
        """创建新Agent并注册到生命周期管理"""
        agent = AgentFactory.create(spec)
        # 注册到ADL
        adl_registry.register(agent.identity, spec)
        # 注册到状态机
        aef_sm = AgentStateMachine(agent)
        # 设置TTL（防止僵尸）
        aef_sm.set_ttl(spec.max_lifetime)
        return aef_sm.transition("CREATED→INITIALIZED")

# conductor-workflow.yaml
name: code-review-pipeline
steps:
  - id: static-analysis
    agent: linter-agent
    inputs:
      files: "{{ trigger.changed_files }}"
    on_failure: report-and-continue

  - id: security-scan
    agent: security-agent
    depends_on: [static-analysis]
    inputs:
      files: "{{ steps.static-analysis.output.passed_files }}"
    on_failure: halt

  - id: review
    agent: reviewer-agent
    depends_on: [static-analysis, security-scan]
    parallel: true  # 多个reviewer并行
    instances: 3
    inputs:
      diff: "{{ trigger.diff }}"

  - id: consensus
    type: aggregate
    depends_on: [review]
    strategy: majority-vote

  - id: merge-check
    agent: merge-agent
    depends_on: [consensus]
    condition: "{{ steps.consensus.output.approved }}"

Issue Created → Agent Spawned → Working Branch → Commits → PR → Review → Merged → Agent Terminated

graph LR
    subgraph 时间轴["时间维度"]
        T1["创建"] --> T2["初始化"] --> T3["执行"] --> T4["挂起"] --> T5["恢复"] --> T6["终止"]
    end

    subgraph 关系轴["关系维度"]
        P["父Agent"] --> C1["子Agent-1"]
        P --> C2["子Agent-2"]
        C1 --> GC["孙Agent"]
    end

    subgraph 资源轴["资源维度"]
        R1["Token消耗"]
        R2["工具调用"]
        R3["API成本"]
    end

# Agent生命周期Hook示例
class AgentLifecycleHooks:
    @hook("on_spawn")
    def on_spawn(self, agent, parent):
        """Agent创建时：注册到ADL，分配身份"""
        adl_registry.register(agent)
        trace.start_span(f"agent.{agent.id}.lifecycle")

    @hook("on_checkpoint")
    def on_checkpoint(self, agent, state):
        """Agent状态checkpoint：保存到持久存储"""
        state_store.save(agent.id, state)
        metrics.record("checkpoint.size", state.size_bytes)

    @hook("on_delegate")
    def on_delegate(self, parent, child, scope):
        """Agent委托：验证信任链"""
        if not aitlp.verify_delegation(parent.credential, child.credential, scope):
            raise TrustChainViolationError()

    @hook("on_retire")
    def on_retire(self, agent):
        """Agent退役：清理资源，归档历史"""
        resource_pool.release(agent.allocated_resources)
        archive.store(agent.execution_history)
        adl_registry.deregister(agent.id)

conceived → born → active → idle → suspended → forked → migrated → retired

# ALP退役流程
class ALPRetirementManager:
    async def retire_agent(self, agent_id, policy="graceful"):
        agent = await self.registry.get(agent_id)

        if policy == "graceful":
            # 等待当前任务完成（带超时）
            await agent.wait_for_completion(timeout=300)
        elif policy == "immediate":
            # 立即中断，checkpoint当前状态
            state = await agent.checkpoint()
            await self.state_store.save(agent_id, state)

        # 递归退役所有子Agent
        children = await self.registry.get_children(agent_id)
        for child in children:
            await self.retire_agent(child.id, policy)

        # 清理资源
        await self.resource_pool.release_all(agent_id)
        await self.adl.deregister(agent_id)
        await self.archive.store(agent_id, agent.history)

        # 通知观察者
        await self.event_bus.publish("agent.retired", {
            "agent_id": agent_id,
            "reason": policy,
            "children_affected": len(children)
        })

sequenceDiagram
    participant Dev as 开发者
    participant ADL as ADL注册中心
    participant Orch as 编排器
    participant Lint as Linter Agent
    participant Sec as Security Agent
    participant Rev as Reviewer Agent
    participant ALP as ALP治理

    Dev->>ADL: 提交ADL定义(3个Agent角色)
    ADL->>ADL: 验证权限约束
    Dev->>Orch: 触发审查工作流
    Orch->>ALP: 请求创建3个Agent

    ALP->>Lint: spawn(conceived→born→active)
    ALP->>Sec: spawn(conceived→born→active)
    ALP->>Rev: spawn(conceived→born→active)

    Note over Lint,Rev: AEF状态机控制执行

    Lint->>Orch: 完成(IDLE)
    Sec->>Orch: 完成(IDLE)
    Rev->>Orch: 完成(IDLE)

    Orch->>ALP: 工作流完成，请求退役
    ALP->>Lint: retire(active→retired)
    ALP->>Sec: retire(active→retired)
    ALP->>Rev: retire(active→retired)

    Note over Lint,Rev: 资源释放·历史归档·身份注销
    ALP->>ADL: 注销3个Agent身份
    ALP->>Dev: 退役确认+审查报告