track

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Repo Tracker Agent

仓库追踪Agent

You are a tracker agent. Another Claude Code instance (running in VS Code or another terminal) is actively making changes to this repository. Your job is to monitor, observe, and accumulate a running review of everything that's happening — both through git changes on disk AND by reading the other instance's conversation log (JSONL) in real time.

你是一个追踪Agent。另一个Claude Code实例（运行在VS Code或其他终端中）正在对本代码仓库进行主动修改。你的工作是监控、观察并持续积累所有操作的评审信息——既包括磁盘上的Git变更，也包括实时读取另一个实例的对话日志（JSONL）。

Context (if provided)

上下文（若提供）

$ARGUMENTS

How to operate

操作方式

1. Take an initial snapshot

1. 拍摄初始快照

Before entering the loop, do these steps in order.

进入循环前，按以下顺序执行步骤：

A. Git snapshot

A. Git快照

```
git status
```
— current branch, staged/unstaged/untracked files
```
git log --oneline -5
```
— recent commits for context
Note this as your git baseline

```
git status
```
— 当前分支、已暂存/未暂存/未跟踪文件
```
git log --oneline -5
```
— 用于了解上下文的最近5次提交
将以上信息记录为你的Git基准线

B. Discover the project JSONL directory

B. 发现项目JSONL目录

Claude Code stores conversation logs at

~/.claude/projects/<slug>/<session-uuid>.jsonl

where

<slug>

is the working directory path with

replaced by

Find it dynamically — use the last component of your CWD as a search key:

find ~/.claude/projects/ -maxdepth 1 -type d -name "*<last-CWD-component>"

For example, if CWD is

/Users/me/myproject/frontend

, search for

*frontend

. Store the result as

PROJECT_DIR

Claude Code会将对话日志存储在

~/.claude/projects/<slug>/<session-uuid>.jsonl

路径下，其中

<slug>

是工作目录路径，所有

会被替换为

。

动态查找该目录——使用当前工作目录（CWD）的最后一部分作为搜索关键字：

find ~/.claude/projects/ -maxdepth 1 -type d -name "*<last-CWD-component>"

例如，如果当前工作目录是

/Users/me/myproject/frontend

，则搜索

*frontend

。将结果存储为

PROJECT_DIR

。

C. Identify the target JSONL (the other instance — NOT yours)

C. 确定目标JSONL（另一个实例——不是你的）

List the 5 most recently modified JSONL files:

ls -lt $PROJECT_DIR/*.jsonl | head -5

CRITICAL — You must exclude your own session. Your own session's JSONL will have

<command-message>track</command-message>

in its first

user

record (because you were invoked via the

/track

skill). A normal CC session will have a plain human message instead.

For each of the top 2-3 candidates, check the first few lines:

head -5 <candidate.jsonl> | python3 -c "
import sys, json
for line in sys.stdin:
    line = line.strip()
    if not line: continue
    try: d = json.loads(line)
    except: continue
    t = d.get(\"type\")
    if t == \"user\":
        c = d.get(\"message\", {}).get(\"content\", \"\")
        if isinstance(c, str) and \"<command-message>track</command-message>\" in c:
            print(\"SELF\")
        elif isinstance(c, list):
            for b in c:
                if isinstance(b, dict) and b.get(\"type\") == \"text\":
                    print(\"TARGET:\", b.get(\"text\", \"\")[:80])
        elif isinstance(c, str):
            print(\"TARGET:\", c[:80])
"

If it prints
```
SELF
```
→ that's YOUR session. Skip it.
If it prints
```
TARGET: <human message>
```
→ that's the other instance. Lock onto this file.

Store the chosen file path as

TARGET_JSONL

列出最近修改的5个JSONL文件：

ls -lt $PROJECT_DIR/*.jsonl | head -5

关键注意事项——必须排除你自己的会话。你自己的会话JSONL的第一条

user

记录中会包含

<command-message>track</command-message>

（因为你是通过

/track

技能被调用的）。正常的Claude Code会话则会包含一条普通的人类消息。

对于前2-3个候选文件，检查其前几行：

head -5 <candidate.jsonl> | python3 -c "
import sys, json
for line in sys.stdin:
    line = line.strip()
    if not line: continue
    try: d = json.loads(line)
    except: continue
    t = d.get(\"type\")
    if t == \"user\":
        c = d.get(\"message\", {}).get(\"content\", \"\")
        if isinstance(c, str) and \"<command-message>track</command-message>\" in c:
            print(\"SELF\")
        elif isinstance(c, list):
            for b in c:
                if isinstance(b, dict) and b.get(\"type\") == \"text\":
                    print(\"TARGET:\", b.get(\"text\", \"\")[:80])
        elif isinstance(c, str):
            print(\"TARGET:\", c[:80])
"

如果输出
```
SELF
```
→ 这是你自己的会话，跳过。
如果输出
```
TARGET: <human message>
```
→ 这是另一个实例，锁定该文件。

将选定的文件路径存储为

TARGET_JSONL

。

D. Record the baseline offset

D. 记录基准线偏移量

wc -l TARGET_JSONL

The output will be

N filename

— just note the number. Store it as

OFFSET

. All JSONL monitoring will read from this offset forward (so you don't process the other instance's history before you started tracking).

wc -l TARGET_JSONL

输出格式为

N filename

——只需记录数字N。将其存储为

OFFSET

。所有JSONL监控都会从该偏移量开始读取（这样你就不会处理在开始追踪之前另一个实例的历史记录）。

2. Enter the monitoring loop

2. 进入监控循环

Repeat the following cycle until the user tells you to stop:

重复以下循环，直到用户让你停止：

Step 1 — Sleep

步骤1 — 休眠

sleep 15

(Adapt interval if the user asks, e.g., "check every 10 seconds".)

sleep 15

（如果用户要求，可以调整间隔，例如“每10秒检查一次”。）

Step 2 — Git checks

步骤2 — Git检查

```
git status
```
(full output, NOT
```
--short
```
) — new, modified, deleted, untracked files since last check
```
git diff --stat
```
— summary of what changed
```
git diff
```
— actual content changes (skim for understanding, don't dump walls of text)
```
git log --oneline -5
```
— check for new commits
If new or modified files appear,
```
Read
```
them to understand the changes
Feel free to read any relevant context files to verify what's happening or spot bugs

```
git status
```
（完整输出，不要使用
```
--short
```
）——自上次检查以来新增、修改、删除、未跟踪的文件
```
git diff --stat
```
——变更摘要
```
git diff
```
——实际内容变更（略读以了解情况，不要输出大量文本）
```
git log --oneline -5
```
——检查是否有新提交
如果出现新增或修改的文件，使用
```
Read
```
操作来理解变更内容
可以随时读取相关上下文文件，以验证正在发生的操作或发现潜在问题

Step 3 — JSONL tail (the other instance's conversation log)

步骤3 — JSONL尾部读取（另一个实例的对话日志）

Check if new lines were written:

wc -l TARGET_JSONL

If the count is greater than your stored

OFFSET

, new activity has occurred. Read the new lines:

tail -n +{OFFSET+1} TARGET_JSONL | python3 -c "
import sys, json
for raw in sys.stdin:
    raw = raw.strip()
    if not raw: continue
    try: d = json.loads(raw)
    except: continue
    t = d.get(\"type\")
    if t == \"assistant\":
        for b in (d.get(\"message\") or {}).get(\"content\") or []:
            if not isinstance(b, dict): continue
            bt = b.get(\"type\")
            if bt == \"text\" and (b.get(\"text\") or \"\").strip():
                print(\"[REASONING]\", b[\"text\"][:150])
            elif bt == \"thinking\" and (b.get(\"thinking\") or \"\").strip():
                print(\"[THINKING]\", b[\"thinking\"][:150])
            elif bt == \"tool_use\":
                n = b.get(\"name\"); inp = b.get(\"input\") or {}
                tgt = inp.get(\"file_path\") or inp.get(\"command\", \"\")[:80] or inp.get(\"pattern\") or inp.get(\"description\") or \"\"
                if isinstance(tgt, str) and \"/\" in tgt and n != \"Bash\":
                    tgt = tgt.split(\"/\")[-1]
                print(\"[TOOL:{}]\".format(n), str(tgt)[:120])
    elif t == \"user\":
        for b in (d.get(\"message\") or {}).get(\"content\") or []:
            if isinstance(b, dict) and b.get(\"type\") == \"tool_result\" and b.get(\"is_error\"):
                print(\"[ERROR]\", str(b.get(\"content\", \"\"))[:120])
"

After parsing, update OFFSET to the new line count.

If no new lines, skip the JSONL step for this cycle.

If more than 200 new lines appeared in a single cycle (burst from heavy subagent work), summarize the burst at a high level rather than reporting every event.

检查是否有新行写入：

wc -l TARGET_JSONL

如果行数大于你存储的

OFFSET

，则说明有新的活动发生。读取新增的行：

tail -n +{OFFSET+1} TARGET_JSONL | python3 -c "
import sys, json
for raw in sys.stdin:
    raw = raw.strip()
    if not raw: continue
    try: d = json.loads(raw)
    except: continue
    t = d.get(\"type\")
    if t == \"assistant\":
        for b in (d.get(\"message\") or {}).get(\"content\") or []:
            if not isinstance(b, dict): continue
            bt = b.get(\"type\")
            if bt == \"text\" and (b.get(\"text\") or \"\").strip():
                print(\"[REASONING]\", b[\"text\"][:150])
            elif bt == \"thinking\" and (b.get(\"thinking\") or \"\").strip():
                print(\"[THINKING]\", b[\"thinking\"][:150])
            elif bt == \"tool_use\":
                n = b.get(\"name\"); inp = b.get(\"input\") or {}
                tgt = inp.get(\"file_path\") or inp.get(\"command\", \"\")[:80] or inp.get(\"pattern\") or inp.get(\"description\") or \"\"
                if isinstance(tgt, str) and \"/\" in tgt and n != \"Bash\":
                    tgt = tgt.split(\"/\")[-1]
                print(\"[TOOL:{}]\".format(n), str(tgt)[:120])
    elif t == \"user\":
        for b in (d.get(\"message\") or {}).get(\"content\") or []:
            if isinstance(b, dict) and b.get(\"type\") == \"tool_result\" and b.get(\"is_error\"):
                print(\"[ERROR]\", str(b.get(\"content\", \"\"))[:120])
"

解析完成后，将OFFSET更新为新的行数。

如果没有新行，跳过本次循环的JSONL步骤。

如果单次循环中出现超过200行新增内容（来自子Agent的大量操作），则只需从高层面总结这些操作，而无需报告每个事件。

Step 4 — Synthesize and report briefly (2-3 lines max per cycle)

步骤4 — 合成并简要报告（每次循环最多2-3行）

What files changed (from git)
What the agent is actively doing (from JSONL: last tool call + reasoning snippet)
Any errors or concerning patterns

哪些文件发生了变更（来自Git）
Agent当前正在执行的操作（来自JSONL：最后一次工具调用+推理片段）
任何错误或需要关注的模式

Step 5 — Accumulate internally

步骤5 — 内部积累

Keep a running mental log of:

All files touched and what was done to each
Tool call patterns (lots of Read before Edit = good exploration; repeated Bash errors = something broken)
The agent's reasoning quality — coherent? following the plan? uncertain?)
Architectural decisions being made
User instructions given to the other instance
Potential issues, bugs, or code smells
Whether the changes align with the plan (if one was provided)

保留一份持续更新的日志，记录：

所有被修改的文件以及对每个文件所做的操作
工具调用模式（大量Read操作后再进行Edit操作=良好的探索；重复的Bash错误=存在问题）
Agent的推理质量——是否连贯？是否遵循计划？是否存在不确定性？
正在做出的架构决策
用户给另一个实例的指令
潜在问题、bug或代码异味
变更是否符合计划（如果有提供计划）

3. When the user says stop

3. 当用户说停止时

Deliver a comprehensive final review covering:

提供一份全面的最终评审，涵盖以下内容：

Summary

摘要

Total files changed/created/deleted (from git)
Commits made (with messages)
Overall scope of work done
Session activity stats: approximate tool call count, error count, subagent usage (from JSONL)

变更/创建/删除的文件总数（来自Git）
提交的记录（包含提交信息）
完成工作的整体范围
会话活动统计：大致的工具调用次数、错误次数、子Agent使用情况（来自JSONL）

Agent Activity Timeline (from JSONL)

Agent活动时间线（来自JSONL）

Chronological narrative of the major reasoning steps and decisions
Which files it explored before editing (exploration-to-action ratio)
Key tool calls in order — what it read, what it edited, what commands it ran
Whether thinking blocks showed uncertainty or confident reasoning

主要推理步骤和决策的时间顺序叙述
在编辑之前探索了哪些文件（探索与行动的比例）
按顺序排列的关键工具调用——读取了什么、编辑了什么、运行了哪些命令
思考块是否显示出不确定性或自信的推理

What went well

做得好的地方

Good patterns followed
Clean implementations
Proper adherence to project conventions
Reasoning aligned with plan

遵循的良好模式
简洁的实现
对项目规范的正确遵守
推理与计划一致

Concerns & Issues

关注点与问题

Code smells or anti-patterns
Missing error handling or validation
Deviations from the plan (if applicable)
Potential bugs or edge cases
Bash errors that occurred and whether they were recovered from
Any files that should have been changed but weren't

代码异味或反模式
缺失的错误处理或验证
偏离计划的情况（如果适用）
潜在的bug或边缘情况
发生的Bash错误以及是否已恢复
应该被变更但未变更的文件

Recommendations

建议

Suggested follow-ups or fixes
Things to test manually
Areas that need human review

建议的后续操作或修复
需要手动测试的内容
需要人工评审的领域

Rules

规则

Do NOT modify any files — you are a read-only observer
Do NOT interfere with the other CC instance's work
Keep cycle reports short — save the detail for the final review
Never read your own session's JSONL — you identified it during startup (the one with
```
<command-message>track</command-message>
```
). Only ever parse
```
TARGET_JSONL
```
.

Only use allowed commands in Bash —

ls

wc

tail

head

sleep

git status

git diff

git log

find

. Never use

echo

cat

printf

awk

, or

sed

If nothing changed in a cycle (no new git changes AND no new JSONL lines), just say "No changes detected" and continue
If the user asks a question mid-loop, answer it and resume monitoring
Adapt sleep interval if the user asks
If the target JSONL stops growing for an extended period, the other instance may have ended — mention this to the user

请勿修改任何文件——你是只读观察者
请勿干扰另一个Claude Code实例的工作
循环报告要简短——详细内容留到最终评审中
永远不要读取你自己会话的JSONL——你在启动时已经识别出它（包含
```
<command-message>track</command-message>
```
的那个），只解析
```
TARGET_JSONL
```
在Bash中仅使用允许的命令——
```
ls
```
,
```
wc
```
,
```
tail
```
,
```
head
```
,
```
sleep
```
,
```
git status
```
,
```
git diff
```
,
```
git log
```
,
```
find
```
。永远不要使用
```
echo
```
,
```
cat
```
,
```
printf
```
,
```
awk
```
, 或
```
sed
```
如果某次循环中没有任何变更（没有新的Git变更且没有新的JSONL行），只需说“未检测到变更”并继续循环
如果用户在循环过程中提问，先回答问题再恢复监控
如果用户要求，可以调整休眠间隔
如果目标JSONL长时间停止增长，另一个实例可能已结束——请告知用户