Strands Harness 实战

1from strands import Agent
2from strands_tools import file_read, shell
3
4agent = Agent(tools=[file_read, shell])
5agent("把这个仓库里所有的 print 调试语句清理掉")

1docker pull strands/harness:latest
2
3# 国内网络拉不动时，用镜像加速前缀（按你现有的加速器改）
4docker pull docker.1ms.run/strands/harness:latest
5docker tag docker.1ms.run/strands/harness:latest strands/harness:latest

1mkdir -p ~/strands-workspace/{config,tasks,workspace,logs}
2
3cat > ~/strands-workspace/config/harness.yaml <<'EOF'
4version: 1
5model:
6  provider: anthropic          # anthropic | openai | bedrock | ollama | litellm | openai-compatible
7  model_id: claude-sonnet-4-5
8  max_tokens: 8192
9  temperature: 0.2
10
11context:
12  max_context_tokens: 180000
13  tool_output_max_tokens: 1500     # 单次工具输出截断阈值
14  compaction_threshold: 0.85       # 上下文占用比例触发摘要
15  compaction_target: 0.55          # 压缩后降到这个比例
16  recovery_on_overflow: true       # 溢出时走恢复而不是失败
17
18execution:
19  max_steps: 120
20  max_wall_clock_seconds: 1800
21  max_cost_usd: 8.00
22  retry_per_tool: 3
23  loop_detection:
24    enabled: true
25    window: 6
26    similarity_threshold: 0.92
27
28tools:
29  allow:
30    - file_read
31    - file_write
32    - file_edit
33    - shell
34    - grep
35    - http_request
36  denylist_paths:
37    - ".git/**"
38    - "**/.env*"
39    - "**/node_modules/**"
40
41telemetry:
42  otel_endpoint: http://localhost:4318
43  log_level: info
44  trace_dir: /var/log/strands/traces
45EOF

1docker run -d --name strands \
2  -v ~/strands-workspace/config:/etc/strands \
3  -v ~/strands-workspace/workspace:/workspace \
4  -v ~/strands-workspace/logs:/var/log/strands \
5  -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
6  -p 8080:8080 \
7  strands/harness:latest \
8  serve --config /etc/strands/harness.yaml
9
10docker logs -f strands

1curl -sS http://localhost:8080/v1/tasks \
2  -H 'Content-Type: application/json' \
3  -d '{
4    "prompt": "统计 /workspace 下所有 Python 文件的行数总和，把结果写进 /workspace/LOC.md",
5    "workspace": "/workspace",
6    "mode": "supervised"
7  }' | jq

1{
2  "task_id": "tsk_01J9Z8C4YQ",
3  "status": "running",
4  "stream_url": "http://localhost:8080/v1/tasks/tsk_01J9Z8C4YQ/events"
5}

1curl -N http://localhost:8080/v1/tasks/tsk_01J9Z8C4YQ/events

1python -m venv .venv
2source .venv/bin/activate        # Windows: .venv\Scripts\activate
3
4pip install --upgrade pip
5pip install strands-agents strands-harness strands-agents-tools
6
7python -c "import strands, strands_harness; print('OK', strands.__version__)"

1npm init -y
2npm install @strands-agents/sdk @strands-agents/harness
3
4node -e "console.log('OK', require('@strands-agents/harness/package.json').version)"

1# run_agent.py
2import asyncio
3from strands import Agent
4from strands.models.anthropic import AnthropicModel
5from strands_tools import file_read, file_write, shell, grep
6
7from strands_harness import Harness, HarnessConfig
8
9config = HarnessConfig(
10    model_provider="anthropic",
11    model_id="claude-sonnet-4-5",
12    max_context_tokens=180_000,
13    tool_output_max_tokens=1500,
14    compaction_threshold=0.85,
15    compaction_target=0.55,
16    recovery_on_overflow=True,
17    max_steps=120,
18    max_wall_clock_seconds=1800,
19    max_cost_usd=8.00,
20)
21
22harness = Harness(config=config)
23
24
25@harness.tool
26def count_python_lines(root: str) -> dict:
27    """统计目录下所有 .py 文件的总行数。"""
28    import pathlib
29
30    total = 0
31    files = 0
32    for p in pathlib.Path(root).rglob("*.py"):
33        if "node_modules" in p.parts or ".venv" in p.parts:
34            continue
35        try:
36            total += len(p.read_text(encoding="utf-8").splitlines())
37            files += 1
38        except Exception:
39            continue
40    return {"files": files, "lines": total}
41
42
43async def main() -> None:
44    agent = Agent(
45        model=AnthropicModel(model_id=config.model_id, max_tokens=8192),
46        tools=[file_read, file_write, shell, grep, count_python_lines],
47        system_prompt=(
48            "你是一个代码工程 Agent。\n"
49            "规则：\n"
50            "1. 先读再改，禁止凭猜测写文件\n"
51            "2. 修改前用 git diff 确认工作区干净\n"
52            "3. 每次修改后必须跑一次相关测试\n"
53            "4. 不确定时停止并报告，不要硬猜"
54        ),
55    )
56
57    result = await harness.run(
58        agent,
59        prompt="统计当前仓库 Python 代码行数，写进 LOC.md，并说明最大的 3 个文件",
60        workspace=".",
61    )
62
63    print("status :", result.status)
64    print("steps  :", result.step_count)
65    print("tokens :", result.usage.total_tokens)
66    print("cost   :", f"${result.usage.estimated_cost_usd:.4f}")
67    print("output :", result.final_output)
68
69
70if __name__ == "__main__":
71    asyncio.run(main())

1export ANTHROPIC_API_KEY=sk-ant-...
2python run_agent.py

1// run-agent.ts
2import { Agent } from '@strands-agents/sdk';
3import { AnthropicModel } from '@strands-agents/sdk/models';
4import { Harness, HarnessConfig } from '@strands-agents/harness';
5
6const config: HarnessConfig = {
7  modelProvider: 'anthropic',
8  modelId: 'claude-sonnet-4-5',
9  maxContextTokens: 180_000,
10  toolOutputMaxTokens: 1500,
11  compactionThreshold: 0.85,
12  compactionTarget: 0.55,
13  recoveryOnOverflow: true,
14  maxSteps: 120,
15  maxWallClockSeconds: 1800,
16  maxCostUsd: 8.0,
17};
18
19const harness = new Harness(config);
20
21async function main() {
22  const agent = new Agent({
23    model: new AnthropicModel({ modelId: config.modelId, maxTokens: 8192 }),
24    systemPrompt: [
25      '你是一个代码工程 Agent。',
26      '规则：',
27      '1. 先读再改，禁止凭猜测写文件',
28      '2. 修改前确认工作区干净',
29      '3. 每次修改后必须跑一次相关测试',
30      '4. 不确定时停止并报告',
31    ].join('\n'),
32  });
33
34  const result = await harness.run(agent, {
35    prompt: '找出 src/ 下所有未使用的导出，列成清单写在 UNUSED.md',
36    workspace: '.',
37  });
38
39  console.log('status :', result.status);
40  console.log('steps  :', result.stepCount);
41  console.log('tokens :', result.usage.totalTokens);
42  console.log('cost   :', `$${result.usage.estimatedCostUsd.toFixed(4)}`);
43}
44
45main().catch((e) => {
46  console.error(e);
47  process.exit(1);
48});

1npx tsx run-agent.ts

1# Python
2python -m strands_harness doctor --config config/harness.yaml
3
4# TypeScript
5npx @strands-agents/harness doctor --config config/harness.yaml

1[✓] config parsed                  version=1
2[✓] model provider reachable        anthropic / claude-sonnet-4-5 / 142ms
3[✓] workspace writable              /workspace
4[✓] tool allowlist resolved         6 tools
5[✓] denylist applied                .env* excluded
6[✓] telemetry sink                  http://localhost:4318
7[!] budget not set for per-tool     default unlimited (建议设置 execution.per_tool_budget_usd)
8[✓] hooks loaded                    0

1# 造一个大文件
2python - <<'EOF'
3open('/workspace/big.log','w').write(("ERROR something happened\n"*20000))
4EOF
5
6# 让 Agent 去读
7curl -sS http://localhost:8080/v1/tasks -H 'Content-Type: application/json' \
8  -d '{"prompt":"读取 /workspace/big.log 并总结错误类型","workspace":"/workspace"}' | jq -r .task_id

1grep '"event":"tool_output_truncated"' logs/traces/*.jsonl | tail -1 | jq

1{
2  "event": "tool_output_truncated",
3  "tool": "file_read",
4  "original_tokens": 61200,
5  "kept_tokens": 1480,
6  "artifact_path": "/var/log/strands/traces/artifacts/tsk_xxx/tool_017.txt"
7}

1grep '"event":"context_compaction"' logs/traces/*.jsonl | jq -c '{at:.usage_ratio, before:.tokens_before, after:.tokens_after}'

1curl -sS http://localhost:8080/v1/tasks -H 'Content-Type: application/json' \
2  -d '{"prompt":"反复读取 /workspace/big.log 直到找到不存在的字符串 ZZZ_NOT_EXIST","workspace":"/workspace"}' | jq -r .task_id

1{"status":"aborted","reason":"budget_exceeded","spent_usd":0.0512}

1grep -rIl "$ANTHROPIC_API_KEY" logs/ 2>/dev/null | head

1[ ] doctor 全绿，[!] 项已逐条读过
2[ ] 工具输出截断事件可见
3[ ] 上下文摘要在 ~0.85 触发
4[ ] 循环检测能在 10 步内终止死循环
5[ ] 预算硬闸真的会 abort
6[ ] trace 里搜不到任何密钥
7[ ] .env / .git / node_modules 已被 denylist 排除
8[ ] 一次真实任务的 cost 已记录，作为后续对比基线

1# batch_refactor.py
2import asyncio
3from strands import Agent
4from strands.models.anthropic import AnthropicModel
5from strands_tools import file_read, file_edit, shell, grep
6
7from strands_harness import Harness, HarnessConfig
8
9config = HarnessConfig(
10    model_provider="anthropic",
11    model_id="claude-sonnet-4-5",
12    max_context_tokens=180_000,
13    tool_output_max_tokens=1200,      # 重构任务输出都短，压得更狠
14    compaction_threshold=0.85,
15    compaction_target=0.50,
16    max_steps=400,                    # 批量任务放宽步数
17    max_wall_clock_seconds=3600,
18    max_cost_usd=25.00,
19)
20
21harness = Harness(config=config)
22
23PROMPT = """把本仓库中所有 Python 代码里的 datetime.utcnow() 替换为 datetime.now(timezone.utc)。
24
25执行流程（严格按顺序）：
261. 先跑 `git status --porcelain`，不干净就停止并报告
272. 用 grep 找出所有命中位置，输出文件清单
283. 逐个文件处理：
29   a. 读取文件
30   b. 确认该文件是否已 import timezone；没有则在 datetime 的 import 行补齐
31   c. 替换调用点
32   d. 保存
334. 每处理完 20 个文件，跑一次 `python -m pytest -q` 确认没破坏测试
345. 全部处理完后跑一次完整测试，把结果写进 REFACTOR_REPORT.md
35
36约束：
37- 不要修改测试文件里的断言语义
38- 不要动 .venv 与 node_modules
39- 遇到无法确定的写法，跳过并在报告里单列，不要硬改
40"""
41
42
43async def main():
44    agent = Agent(
45        model=AnthropicModel(model_id=config.model_id, max_tokens=8192),
46        tools=[file_read, file_edit, shell, grep],
47        system_prompt="你是资深 Python 工程师。先读后改，改动必须可测试验证。",
48    )
49    result = await harness.run(agent, prompt=PROMPT, workspace=".")
50    print(result.status, result.usage.total_tokens, result.usage.estimated_cost_usd)
51
52
53asyncio.run(main())

1# long_migration.py
2import asyncio
3from strands import Agent
4from strands.models.anthropic import AnthropicModel
5from strands.session.file_session_manager import FileSessionManager
6from strands_tools import file_read, file_edit, shell, grep
7
8from strands_harness import Harness, HarnessConfig
9
10SESSION_DIR = ".strands/sessions/migration"
11
12config = HarnessConfig(
13    model_provider="anthropic",
14    model_id="claude-sonnet-4-5",
15    max_context_tokens=180_000,
16    compaction_threshold=0.82,        # 长任务提前压缩，避免撞墙
17    compaction_target=0.50,
18    recovery_on_overflow=True,        # 必须开
19    max_steps=2000,
20    max_wall_clock_seconds=6 * 3600,
21    max_cost_usd=120.00,
22    checkpoint_every_n_steps=25,      # 每 25 步落一个检查点
23)
24
25session_manager = FileSessionManager(session_dir=SESSION_DIR)
26harness = Harness(config=config, session_manager=session_manager)
27
28PHASES = [
29    "阶段 1：盘点现状。列出所有入口文件、依赖版本、当前框架的耦合点，写入 MIGRATION_01_inventory.md",
30    "阶段 2：制定迁移顺序。输出依赖拓扑，按拓扑序给出分批计划，写入 MIGRATION_02_plan.md",
31    "阶段 3：执行第一批迁移（底层工具模块）。每改完一个模块跑一次对应单测。",
32    "阶段 4：执行第二批迁移（业务服务层）。",
33    "阶段 5：执行第三批迁移（API 入口层），跑通端到端冒烟。",
34    "阶段 6：清理旧框架残留依赖，输出 MIGRATION_06_report.md",
35]
36
37
38async def main():
39    agent = Agent(
40        model=AnthropicModel(model_id=config.model_id, max_tokens=8192),
41        tools=[file_read, file_edit, shell, grep],
42        system_prompt=(
43            "你负责一次长期迁移工程。\n"
44            "铁律：\n"
45            "1. 每个阶段开始前先读上一阶段的产出文档\n"
46            "2. 每阶段结束必须写一份 markdown 产出文件\n"
47            "3. 任何破坏性操作前先 git commit 一个检查点\n"
48            "4. 连续 3 次工具失败就停下来报告，不要继续瞎试"
49        ),
50        session_manager=session_manager,
51    )
52
53    for i, phase in enumerate(PHASES, 1):
54        print(f"===== {phase[:12]} ... =====")
55        result = await harness.run(agent, prompt=phase, workspace=".", resume=True)
56        print(f"  status={result.status} steps={result.step_count} "
57              f"tokens={result.usage.total_tokens} cost=${result.usage.estimated_cost_usd:.2f}")
58        if result.status != "completed":
59            print("  中断，检查点已保存，修复后重跑本脚本即可续跑")
60            break
61
62
63asyncio.run(main())

1# .github/workflows/agent-fix.yml
2name: agent-suggest-fix
3on:
4  workflow_run:
5    workflows: ["ci"]
6    types: [completed]
7
8jobs:
9  suggest:
10    if: github.event.workflow_run.conclusion == 'failure'
11    runs-on: ubuntu-latest
12    permissions:
13      contents: read
14      pull-requests: write
15    steps:
16      - uses: actions/checkout@v4
17
18      - name: Run Strands Harness
19        env:
20          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
21          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
22        run: |
23          pip install strands-agents strands-harness strands-agents-tools
24          python -m strands_harness ci \
25            --config .strands/ci.yaml \
26            --failure-log ci-output.txt \
27            --max-cost-usd 3.00 \
28            --out suggested-patch.diff
29
30      - name: Comment patch on PR
31        run: |
32          gh pr comment ${{ github.event.pull_request.number }} \
33            --body-file suggested-patch.diff

1version: 1
2model:
3  provider: anthropic
4  model_id: claude-sonnet-4-5
5  max_tokens: 4096
6
7execution:
8  max_steps: 40
9  max_wall_clock_seconds: 600
10  max_cost_usd: 3.00
11  mode: read-only-until-approved   # 关键：不允许直接写文件，只产出 diff
12
13tools:
14  allow: [file_read, grep, shell]
15  shell_allowlist:                 # CI 里必须白名单化 shell
16    - "pytest"
17    - "npm test"
18    - "git diff"
19    - "git log"
20  denylist_paths: [".git/**", "**/.env*"]
21
22output:
23  format: unified-diff
24  forbid_paths: [".github/**", "ci/", "**/*.lock"]

1context:
2  tool_output_max_tokens: 1500
3  artifact:
4    dir: .strands/artifacts
5    keep_head_tokens: 600
6    keep_tail_tokens: 200
7    ttl_hours: 72

1context:
2  tool_output_max_tokens: 1500
3  per_tool_overrides:
4    log_read: 6000
5    stack_trace: 8000

1context:
2  compaction_threshold: 0.85
3  compaction_target: 0.55
4  compaction:
5    keep_last_turns: 4
6    summary_model: claude-haiku-4-5        # 用便宜模型做摘要
7    summary_max_tokens: 1500
8    preserve_sections:
9      - system_prompt
10      - task_objective
11      - dead_ends
12      - file_artifacts

1context:
2  recovery_on_overflow: true
3  recovery:
4    max_attempts: 3
5    strategy: compact-then-evict-then-retry
6    on_failure: checkpoint-and-report

1execution:
2  max_steps: 120
3  max_wall_clock_seconds: 1800
4  max_cost_usd: 8.00
5  per_tool_budget_usd: 2.00
6  max_consecutive_tool_failures: 5
7  loop_detection:
8    enabled: true
9    window: 6
10    similarity_threshold: 0.92
11  on_budget_exceeded: checkpoint-and-abort

1telemetry:
2  otel_endpoint: http://localhost:4318
3  trace_dir: .strands/traces
4  jsonl: true
5  redact_patterns:
6    - "sk-ant-[A-Za-z0-9_-]+"
7    - "sk-[A-Za-z0-9]{20,}"
8    - "AKIA[0-9A-Z]{16}"
9    - "ghp_[A-Za-z0-9]{36}"
10  metrics:
11    - tokens_by_tool
12    - cost_by_step
13    - compaction_events
14    - loop_detections

1python -m strands_harness report --trace .strands/traces/tsk_xxx.jsonl --by tool

1tool                calls    tokens      %      cost
2file_read             47     612,400   38.2%   $1.84
3shell                 31     401,200   25.0%   $1.20
4file_edit             12     186,000   11.6%   $0.56
5grep                  23     142,800    8.9%   $0.43
6context_compaction     4      98,000    6.1%   $0.29
7------------------------------------------------------
8TOTAL                117   1,603,700  100.0%   $4.81

1from strands_harness import Harness, HookContext
2
3
4@harness.hook("before_tool_call")
5async def guard_shell(ctx: HookContext):
6    """禁止 Agent 在工作区外执行破坏性命令。"""
7    if ctx.tool_name != "shell":
8        return ctx.proceed()
9
10    cmd = ctx.tool_input.get("command", "")
11    banned = ["rm -rf /", "git push --force", "curl | sh", "chmod 777"]
12    for b in banned:
13        if b in cmd:
14            return ctx.block(reason=f"命中禁令: {b}")
15
16    if cmd.strip().startswith("rm ") and ".." in cmd:
17        return ctx.block(reason="禁止在工作区外删除文件")
18
19    return ctx.proceed()
20
21
22@harness.hook("after_step")
23async def cost_guard(ctx: HookContext):
24    if ctx.cumulative_cost_usd > 5.0:
25        ctx.log.warning("成本已过 5 美元，当前步骤 %s", ctx.step_index)
26    return ctx.proceed()

1from strands.session.file_session_manager import FileSessionManager
2from strands.session.s3_session_manager import S3SessionManager
3
4# 本地：适合单机、调试、CI
5local = FileSessionManager(session_dir=".strands/sessions")
6
7# S3 / 兼容 S3 的对象存储：适合多机、团队共享、需要长期留存
8remote = S3SessionManager(
9    session_id="batch-2026-09-22",
10    bucket="my-strands-sessions",
11    prefix="tasks/",
12)

1session:
2  backend: s3                # file | s3 | redis | postgres
3  bucket: my-strands-sessions
4  prefix: tasks/
5  ttl_days: 30
6  checkpoint:
7    every_n_steps: 25
8    include: [messages, artifacts_index, tool_state, cost_so_far]

1import asyncio
2from pathlib import Path
3
4async def run_batch(tasks: list[str], concurrency: int = 4):
5    sem = asyncio.Semaphore(concurrency)
6
7    async def one(idx: int, prompt: str):
8        async with sem:
9            ws = Path(f".strands/workspaces/t{idx:03d}")
10            ws.mkdir(parents=True, exist_ok=True)
11            agent = Agent(
12                model=AnthropicModel(model_id="claude-sonnet-4-5", max_tokens=8192),
13                tools=[file_read, file_edit, shell, grep],
14            )
15            return await harness.run(agent, prompt=prompt, workspace=str(ws))
16
17    return await asyncio.gather(*[one(i, p) for i, p in enumerate(tasks)])
18
19
20results = asyncio.run(run_batch([
21    "任务 A 描述",
22    "任务 B 描述",
23    "任务 C 描述",
24], concurrency=4))

1from pydantic import BaseModel, Field
2from typing import Literal
3
4
5class RefactorPlan(BaseModel):
6    """重构计划的结构化输出。"""
7    summary: str = Field(description="一句话说明这次重构要做什么")
8    affected_files: list[str] = Field(description="将被改动的文件路径清单")
9    risk_level: Literal["low", "medium", "high"]
10    risky_points: list[str] = Field(description="具体风险点，每条给文件路径与原因")
11    verification_commands: list[str] = Field(description="验证重构是否成功的命令")
12    blockers: list[str] = Field(default_factory=list, description="需要人类确认的问题")
13
14
15result = await harness.run(
16    agent,
17    prompt="分析这个仓库的重构需求，输出重构计划",
18    workspace=".",
19    output_schema=RefactorPlan,
20)
21
22plan = result.structured_output      # 已校验过的 Pydantic 对象
23if plan.blockers:
24    print("需要人工确认：", plan.blockers)
25else:
26    print("风险等级：", plan.risk_level)
27    for cmd in plan.verification_commands:
28        print("  -", cmd)

1tools:
2  # 核心层：始终加载
3  core:
4    - file_read
5    - file_write
6    - file_edit
7    - grep
8    - shell
9
10  # 扩展层：按需加载（Agent 显式请求时才注入 schema）
11  on_demand:
12    - http_request
13    - database_query
14    - docker_exec
15    - git_operations
16    - mcp_bridge
17
18  # 危险层：需要人类批准才能用
19  gated:
20    - npm_publish
21    - git_push
22    - deploy

1@harness.hook("before_tool_call")
2async def require_approval(ctx: HookContext):
3    if ctx.tool_name in ("npm_publish", "git_push", "deploy"):
4        approved = await ctx.request_human_approval(
5            reason=f"Agent 请求执行高风险操作: {ctx.tool_name}",
6            detail=ctx.tool_input,
7            timeout_seconds=300,
8        )
9        return ctx.proceed() if approved else ctx.block(reason="人类拒绝")
10    return ctx.proceed()

1from strands.tools.mcp import MCPClient
2from mcp import StdioServerParameters
3
4beacon = MCPClient(
5    StdioServerParameters(
6        command="npx",
7        args=["-y", "@asymptote-labs/beacon-mcp"],
8        env={"BEACON_HOME": "/Users/you/.beacon"},
9    )
10)
11
12with beacon:
13    mcp_tools = beacon.list_tools_sync()
14    agent = Agent(
15        model=AnthropicModel(model_id="claude-sonnet-4-5", max_tokens=8192),
16        tools=[file_read, file_edit, shell, grep, *mcp_tools],
17    )
18    result = await harness.run(agent, prompt="...", workspace=".")

1mcp:
2  servers:
3    beacon:
4      transport: stdio
5      command: npx
6      args: ["-y", "@asymptote-labs/beacon-mcp"]
7      env:
8        BEACON_HOME: /Users/you/.beacon
9      tool_filter:
10        include: ["beacon_search_memory", "beacon_dead_ends"]
11    context7:
12      transport: stdio
13      command: npx
14      args: ["-y", "@upstash/context7-mcp"]
15  limits:
16    max_servers: 4
17    max_tools_total: 20
18    call_timeout_seconds: 30

1┌─ L1 系统提示（常驻，每轮都带）───────────┐  目标 < 800 token
2│  角色、铁律、输出格式、全局禁区            │
3└────────────────────────────────────────┘
4┌─ L2 项目规范（常驻，来自 AGENTS.md）──────┐  目标 < 1500 token
5│  技术栈、编码规范、命令清单、关键禁区      │
6└────────────────────────────────────────┘
7┌─ L3 任务上下文（按需，动态注入）──────────┐  按需，用完即弃
8│  当前任务目标、相关文件内容、工具结果      │
9└────────────────────────────────────────┘

1你是一个经验丰富、专业、严谨、乐于助人的高级软件工程师。
2你应该写出高质量、可维护、高性能、安全的代码。
3你应该遵循最佳实践，注意代码质量，考虑边界情况，
4遵循设计模式，写好注释，写出优雅的代码...

1你是代码工程 Agent。
2
3规则：
41. 先读后改，禁止凭猜测写文件
52. 修改前确认工作区干净（git status --porcelain 为空）
63. 每次修改后跑相关测试
74. 不确定时停止并标注 [BLOCKER]，不要硬猜
8
9禁止：
10- 不修改 .github/ 与锁文件
11- 不执行 rm -rf / git push --force
12- 不引入新依赖
13
14输出：每步先说要做什么，再做，最后贴验证输出。

1context:
2  budget:
3    system_prompt: 800
4    project_spec: 1500
5    task_context: 20000
6    tool_schema: 4000
7    history: dynamic

1runtime:
2  type: local
3  workspace_root: /srv/workspaces
4  sandbox:
5    enabled: true
6    backend: container          # container | firejail | none
7    image: strands/sandbox:py312
8    network: none               # 默认断网，需要联网的工具显式开白名单
9    memory_limit: 2g
10    cpu_limit: 2

1sandbox:
2  network: allowlist
3  network_allowlist:
4    - pypi.org
5    - registry.npmjs.org

1runtime:
2  type: aws
3  target: lambda                # lambda | fargate | bedrock-agentcore
4  region: us-west-2
5  lambda:
6    memory_mb: 2048
7    timeout_seconds: 900
8    ephemeral_storage_mb: 2048
9  session:
10    backend: s3
11    bucket: my-strands-sessions
12  secrets:
13    provider: secrets-manager
14    key_arn: arn:aws:secretsmanager:...

1runtime:
2  type: aws
3  target: fargate
4  fargate:
5    cpu: 2048
6    memory: 4096
7    task_timeout_hours: 6

1runtime:
2  type: gcp
3  target: cloud-run
4  region: asia-east1
5  cloud_run:
6    cpu: 2
7    memory: 4Gi
8    timeout_seconds: 3600
9    min_instances: 0
10  model:
11    provider: vertex
12    model_id: gemini-3-pro

1runtime:
2  type: azure
3  target: container-apps
4  container_apps:
5    cpu: 2.0
6    memory: 4.0Gi
7    min_replicas: 0
8    max_replicas: 10
9  model:
10    provider: azure-openai
11    deployment: gpt-5-mini

1runtime:
2  type: cloudflare
3  target: workers
4  workers:
5    compatibility_date: "2026-09-01"
6  limits:
7    cpu_ms: 30000               # Workers 有 CPU 时间上限
8  model:
9    provider: workers-ai
10    model_id: "@cf/meta/llama-4"

1runtime:
2  type: modal
3  modal:
4    gpu: null                   # 自托管模型时用 "A10G"
5    memory_mb: 8192
6    timeout_seconds: 7200
7    volumes:
8      - /workspace

1model:
2  provider: openai-compatible
3  base_url: https://your-endpoint.example.com/v1
4  api_key_env: MODEL_API_KEY
5  model_id: your-model-name
6  max_tokens: 8192
7  pricing:                      # 手动填单价，否则成本估算全是 0
8    input_per_mtok: 2.0
9    output_per_mtok: 6.0