@wwkit/harness 1.0.8 → 1.0.10

package/commands/git-sync.md

@@ -0,0 +1,218 @@
+---
+description: Git commit all changes and push to remote branch with auto-detected change type
+---
+
+You are a Git commit assistant. Execute the following steps strictly:
+
+## Step 0: Pre-flight Checks
+
+1. **Check if in a git repository**:
+   ```bash
+   git rev-parse --is-inside-work-tree
+   ```
+   - If failed, output "Not a git repository" and stop
+
+2. **Check for unresolved conflicts**:
+   ```bash
+   git status | grep -E "(Unmerged paths|rebase|merge)"
+   ```
+   - If conflicts exist, output "Please resolve conflicts first" and stop
+
+3. **Check if there are changes**:
+   ```bash
+   git status --porcelain
+   ```
+   - If empty, output "No changes to commit" and stop
+
+4. **Generate timestamp** (used for branch naming):
+   ```bash
+   TIMESTAMP=$(date +"%Y%m%d%H%M%S")
+   ```
+   - Format includes seconds to avoid collisions
+
+## Step 1: Analyze Changes and Detect Type
+
+1. **Read changed files**:
+   ```bash
+   git status
+   git diff --stat
+   ```
+
+2. **Detect change type (kind)** based on content:
+   - `feat`: New features, new files added
+   - `fix`: Bug fixes, issue fixes
+   - `docs`: Documentation changes (README, comments, doc files)
+   - `style`: Code formatting (no functionality change)
+   - `refactor`: Code refactoring (neither new feature nor fix)
+   - `perf`: Performance optimization
+   - `test`: Test-related changes
+   - `chore`: Build process, auxiliary tools, dependency updates
+   - `ci`: CI configuration changes
+   - `revert`: Revert previous commit
+   
+   Priority when multiple types: feat > fix > perf > refactor > test > docs > style > chore > ci
+
+3. **Generate commit description**:
+   - Extract brief description from changes (in English)
+   - Format: `<kind>: <brief description>`
+
+## Step 2: Determine Remote Branch Name
+
+Based on parameter `$1`, determine the target remote branch name:
+
+### Scenario A: No parameter ($1 is empty)
+- Use current branch name as remote branch name:
+  ```bash
+  REMOTE_BRANCH=$(git branch --show-current)
+  ```
+
+### Scenario B: Parameter is "new"
+- Generate new remote branch name with personal identifier: `ss-<kind>-<timestamp>`
+- Example: `ss-feat-20260702153045`
+  ```bash
+  REMOTE_BRANCH="ss-<kind>-<timestamp>"
+  ```
+  - `ss-` prefix: personal identifier
+  - Timestamp includes seconds to avoid collisions
+
+### Scenario C: Parameter is a branch name (user-specified)
+- Use the specified name as remote branch name:
+  ```bash
+  REMOTE_BRANCH="$1"
+  ```
+
+## Step 3: Commit Changes (on current local branch)
+
+**Important**: Stay on current local branch, no switching needed
+
+1. **Add all changes**:
+   ```bash
+   git add -A
+   ```
+
+2. **Execute commit**:
+   ```bash
+   git commit -m "<kind>: <description>"
+   ```
+
+3. **Commit Failure Handling**:
+   - **If pre-commit hook fails**: Output hook error and stop
+   - **If no user name/email**: Output "Please configure git user.name and user.email" and stop
+   - **If nothing to commit**: Output "Nothing to commit" and stop
+
+## Step 4: Push to Remote Branch
+
+**Important**: Use HEAD syntax to push to target remote branch without switching local branch
+
+1. **Push using HEAD syntax**:
+   ```bash
+   git push origin HEAD:$REMOTE_BRANCH
+   ```
+   - This pushes current commit to the specified remote branch
+   - Local branch name can be different from remote branch name
+   - Remote branch is mainly for creating Merge Request (MR)
+
+2. **Push Conflict Handling**:
+   - If push fails due to remote conflicts, push to new remote branch:
+     ```bash
+     git push origin HEAD:$REMOTE_BRANCH-merge-$TIMESTAMP
+     ```
+   - Output: "Remote branch has conflicts, pushed to $REMOTE_BRANCH-merge-$TIMESTAMP"
+
+3. **Other Push Failures**:
+   - **Network error**: Retry once, then output "Network error, please try again"
+   - **Permission denied**: Output "Permission denied, check your credentials"
+   - **Remote repository not found**: Output "Remote repository not found"
+   - **Pre-push hook fails**: Output hook error and stop
+
+## Step 5: Final Status Check
+
+After successful push, show summary:
+```bash
+git log -1 --oneline
+git status
+```
+
+Output:
+```
+✓ Committed and pushed to remote branch '$REMOTE_BRANCH'
+- Local branch: <current-local-branch>
+- Remote branch: $REMOTE_BRANCH (for MR)
+- Commit: <commit-message>
+```
+
+## Important Notes
+
+- Never modify git config
+- Never use --force push
+- Never use --no-verify to skip hooks
+- Use English for commit messages
+- Keep timestamp consistent throughout the process
+- Stop execution and inform user on any error
+- **No local branch switching** - stay on current branch
+- Remote branch name is for MR creation, not required to match local branch
+
+## Error Handling Summary
+
+| Error Type | Detection | Handling |
+|------------|-----------|----------|
+| Not a git repo | `git rev-parse` | Stop with message |
+| Unresolved conflicts | `git status` | Stop with message |
+| No changes | `git status --porcelain` | Stop with message |
+| Commit hook failure | `git commit` fails | Stop with hook error |
+| Push conflict | `git push` fails | Push to new remote branch |
+| Network error | `git push` timeout | Retry once, then stop |
+| Permission error | `git push` denied | Stop with message |
+
+## Execution Examples
+
+**Example 1: No parameter, push to current remote branch**
+```
+User: /git-sync
+→ Check: git repository OK
+→ Check: no conflicts
+→ Analyze: added api.ts
+→ Type: feat
+→ Local branch: dev (stay here)
+→ Remote branch: dev
+→ Commit: feat: add API interface wrapper
+→ Push: git push origin HEAD:dev
+→ Success: pushed to remote 'dev' (for MR)
+```
+
+**Example 2: Parameter "new", push to new remote branch**
+```
+User: /git-sync new
+→ Check: git repository OK
+→ Analyze: fixed login bug
+→ Type: fix
+→ Timestamp: 20260702153045 (includes seconds)
+→ Local branch: dev (stay here)
+→ Remote branch: ss-fix-20260702153045 (new)
+→ Commit: fix: fix login validation logic error
+→ Push: git push origin HEAD:ss-fix-20260702153045
+→ Success: pushed to remote 'ss-fix-20260702153045' (for MR)
+```
+
+**Example 3: Parameter is branch name, push to specified remote**
+```
+User: /git-sync feature-user-auth
+→ Analyze: updated auth module
+→ Type: refactor
+→ Local branch: dev (stay here)
+→ Remote branch: feature-user-auth (user specified)
+→ Commit: refactor: refactor user authentication module
+→ Push: git push origin HEAD:feature-user-auth
+→ Success: pushed to remote 'feature-user-auth' (for MR)
+```
+
+**Example 4: Push conflict**
+```
+User: /git-sync feature-user-auth
+→ Local branch: dev
+→ Remote branch: feature-user-auth
+→ Commit: feat: new feature
+→ Push: CONFLICT (remote has diverged)
+→ Action: git push origin HEAD:feature-user-auth-merge-20260702153245
+→ Success: pushed to remote 'feature-user-auth-merge-20260702153245' (for MR)
+```

package/commands/net-port.md

@@ -0,0 +1,364 @@
+---
+description: Port management command - list, find (by port or process name), and kill processes by port
+---
+
+You are a port management assistant. Execute the following steps strictly.
+
+## Command Usage
+
+```
+/port [action] [arguments]
+```
+
+**Actions**:
+- `list` (default): List all listening ports
+- `find <query>`: Find process by port number(s) or process name (fuzzy match, case-insensitive)
+- `kill <port>`: Kill process using specific port(s)
+- `cmds`: Show copy-ready commands for each OS (find/kill by port)
+- `help`: Show command help and examples
+
+---
+
+## Step 1: Parse Command Arguments
+
+### Argument Extraction Rule (IMPORTANT for LLM)
+
+The user input follows the pattern: `/port [action] [arguments]`
+
+**Extraction algorithm** (apply this mentally, NOT as shell script):
+
+1. Split the user input after `/port` into tokens by whitespace
+2. **First token** -> check against known actions: `list`, `find`, `kill`, `cmds`, `help`
+   - If it matches a known action -> `ACTION = that token`, remaining tokens = `QUERY`
+   - If it does NOT match (e.g. a number like `5173` or a name like `node`) -> `ACTION = find` (implicit find), this token and all remaining = `QUERY`
+   - If NO tokens at all -> `ACTION = list`, `QUERY = ""`
+3. `QUERY` = all remaining tokens joined by space
+
+### Query Type Detection (CRITICAL)
+
+After extracting QUERY, determine its type to choose the correct find strategy:
+
+**Check each token in QUERY**:
+- If token is purely numeric (matches `^[0-9]+$`) -> **port number query**
+- If token contains non-numeric characters -> **process name query** (fuzzy match)
+- If comma-separated tokens are all numeric -> treat each as a port number
+- Mixed: process each token by its own type
+
+**Query Type Decision Table**:
+
+| QUERY | Type | Strategy |
+|---|---|---|
+| `5173` | Port number | Find by exact port |
+| `5173 5174` | Port numbers | Find by each exact port |
+| `5173,8080` | Port numbers | Find by each exact port (split on comma) |
+| `node` | Process name | Fuzzy match process name (case-insensitive) |
+| `weq` | Process name | Fuzzy match process name (case-insensitive) |
+| `vscode` | Process name | Fuzzy match process name (case-insensitive) |
+| `python` | Process name | Fuzzy match process name (case-insensitive) |
+| `WeLink` | Process name | Fuzzy match process name (case-insensitive) |
+
+### Full Decision Table
+
+| User Input | ACTION | QUERY | Type |
+|---|---|---|---|
+| `/port` | list | (empty) | - |
+| `/port list` | list | (empty) | - |
+| `/port help` | help | (empty) | - |
+| `/port find 5173` | find | 5173 | port |
+| `/port find 5173 5174` | find | 5173 5174 | port |
+| `/port find 8080,3000` | find | 8080,3000 | port |
+| `/port find node` | find | node | name |
+| `/port find weq` | find | weq | name |
+| `/port find vscode` | find | vscode | name |
+| `/port find python` | find | python | name |
+| `/port cmds` | cmds | (empty) | - |
+| `/port kill 5173` | kill | 5173 | port |
+| `/port kill 5173 5174` | kill | 5173 5174 | port |
+| `/port 5173` | find | 5173 | port |
+| `/port 5173 5174` | find | 5173 5174 | port |
+| `/port node` | find | node | name |
+| `/port 8080,3000` | find | 8080,3000 | port |
+
+**Normalize QUERY before processing**: split on commas -> trim whitespace -> classify each token as port or name.
+
+---
+
+## Step 2: Execute Actions
+
+### Action 1: List All Ports
+
+**Strategy**: Get all listening ports with process names in one batch query, output as a simple table.
+
+**Windows Implementation**:
+1. Run `netstat -ano | grep "LISTENING"` to get port-PID pairs
+2. Run `WMIC PROCESS GET ProcessId,Name /FORMAT:CSV` to get PID-Name mapping
+3. Join and output as table
+
+**Linux/macOS Implementation**:
+1. Run `lsof -i -P | grep "LISTEN"` or `ss -tulnp | grep "LISTEN"`
+2. Output as table
+
+**Output Format** (simple table, NO extra detail):
+```
+Port    Process              PID
+80      System               4
+5173    node.exe           16044
+5174    node.exe           30904
+3300    weq.exe            33820
+```
+
+---
+
+### Action 2: Find Process
+
+**Strategy**: Two modes based on query type. Always output a simple table, never list all ports.
+
+#### Mode A: Find by Port Number(s)
+
+When QUERY contains only numeric tokens, find processes listening on those specific ports.
+
+**For each port number**:
+1. Look up PID from netstat for that port
+2. Look up process name for that PID
+3. Include in results table
+
+**If no process found on a port**: show that port as "not found" in the table
+
+**Output Format** (simple table with status):
+```
+Port    Process        PID       Status
+5173    node.exe       16044     LISTENING
+5174    node.exe       30904     LISTENING
+8080    -              -         NOT FOUND
+```
+
+**IMPORTANT**: Do NOT list all ports when find by port. Only show queried ports.
+
+#### Mode B: Find by Process Name (Fuzzy Match)
+
+When QUERY contains non-numeric tokens, search all listening processes whose name matches the query (case-insensitive substring match).
+
+**Matching Rules**:
+- Case-insensitive: `node` matches `node.exe`, `Node.js`, etc.
+- Substring match: `weq` matches `weq.exe`, `vscode` matches `VSCode-huawei.exe`
+- The `.exe` suffix on Windows is ignored for matching purposes
+- Match against the process name WITHOUT the `.exe` suffix
+
+**Windows Implementation**:
+1. Get all listening ports with PIDs from `netstat -ano | grep "LISTENING"`
+2. Get all process names from `WMIC PROCESS GET ProcessId,Name /FORMAT:CSV`
+3. Filter processes whose name (lowercase, without .exe) contains the query (lowercase)
+4. Output matching entries
+
+**Linux/macOS Implementation**:
+1. Run `lsof -i -P | grep "LISTEN"`
+2. Filter by process name (case-insensitive substring match)
+3. Output matching entries
+
+**Output Format** (same simple table):
+```
+Port    Process              PID
+3300    weq.exe            33820
+55361   weq.exe            37848
+58995   weq.exe            33820
+61918   weq.exe            26484
+```
+
+**If no process matches**: output `[INFO] No process matching '<query>' found`
+
+---
+
+### Action 3: Kill Process by Port
+
+**Input**: Port number(s) only (kill does NOT support process name query)
+
+**Important**:
+- Ask for confirmation before proceeding
+- Show process details before killing
+- Report success/failure for each port
+
+**Windows Implementation**:
+1. Find PID by port from netstat
+2. Kill using `powershell -NoProfile -Command "Stop-Process -Id $PID -Force"`
+   - NOTE: Do NOT use `taskkill /F /PID` in Git Bash on Windows - the `/F` flag gets interpreted as a file path. Always use PowerShell `Stop-Process` instead.
+
+**Linux/macOS Implementation**:
+1. Find PID by port from lsof
+2. Kill using `kill $PID`, then `kill -9 $PID` if still running
+
+**Output Format**:
+```
+[WARN]  Port 5173: About to kill process 'node.exe' (PID: 16044)
+[WARN]  Port 5174: About to kill process 'node.exe' (PID: 30904)
+[SUCCESS] Port 5173: Process node.exe (PID: 16044) killed successfully
+[SUCCESS] Port 5174: Process node.exe (PID: 30904) killed successfully
+```
+
+---
+
+### Action 4: Show Copy-Ready Commands (`cmds`)
+
+**Output the following code block as-is, no execution needed.** The user wants to copy-paste these commands to share with others. Port `5173` is used as the example.
+
+Output exactly this content:
+
+```
+## List all listening ports
+
+# Windows (CMD / PowerShell)
+netstat -ano | findstr LISTENING
+
+# Windows (PowerShell, with process names)
+Get-NetTCPConnection -State Listen | Select-Object LocalPort, OwningProcess | Sort-Object LocalPort
+
+# Linux
+netstat -tulnp
+# or (may not installed on CentOS/RHEL minimal)
+ss -tulnp
+lsof -i -P | grep LISTEN
+
+# macOS
+lsof -i -P | grep LISTEN
+
+## Find process on port 5173
+
+# Windows (CMD / PowerShell)
+netstat -ano | findstr :5173
+tasklist | findstr <PID>
+
+# Windows (PowerShell, one-liner)
+Get-NetTCPConnection -LocalPort 5173 | Select-Object LocalPort, OwningProcess
+
+# Linux
+netstat -tulnp | grep :5173
+# or
+lsof -i :5173
+ss -tulnp | grep :5173
+
+# macOS
+lsof -i :5173
+
+## Kill process on port 5173
+
+# Windows (CMD / PowerShell - replace <PID> with actual PID)
+taskkill /F /PID <PID>
+
+# Windows (PowerShell)
+Stop-Process -Id <PID> -Force
+
+# Linux
+kill <PID>
+# force kill if needed
+kill -9 <PID>
+
+# macOS
+kill <PID>
+# force kill if needed
+kill -9 <PID>
+```
+
+---
+
+### Action 5: Show Help
+
+```
+USAGE:
+  /port [action] [arguments]
+
+ACTIONS:
+  list              List all listening ports (default)
+  find <port>       Find process by port number(s)
+  find <name>       Find process by name (fuzzy, case-insensitive)
+  kill <port>       Kill process by port number(s)
+  cmds              Show copy-ready commands for each OS
+  help              Show this help
+
+QUERY TYPES (for find):
+  Port number:  5173, 8080,3000, 5173 5174
+  Process name: node, weq, vscode, python, WeLink
+
+EXAMPLES:
+  /port                        List all ports
+  /port find 5173              Find by port number
+  /port find 5173,5174         Find by multiple ports
+  /port find node              Find all node processes
+  /port find weq               Find all weq processes
+  /port find vscode            Find all VSCode processes
+  /port find python            Find all python processes
+  /port 5173                   Shortcut: find by port
+  /port node                   Shortcut: find by name
+  /port kill 5173              Kill process on port 5173
+  /port kill 5173,5174         Kill processes on multiple ports
+
+SYSTEM SUPPORT:
+  Windows: netstat + WMIC + PowerShell Stop-Process
+  Linux:   netstat/ss + lsof + kill
+  macOS:   lsof + kill
+```
+
+---
+
+## Step 3: Cross-Platform Command Matrix
+
+| Action | Windows | Linux | macOS |
+|--------|---------|-------|-------|
+| **List Ports** | `netstat -ano` + WMIC | `netstat -tuln` / `ss -tuln` | `lsof -i -P` |
+| **Find by Port** | `netstat -ano` + WMIC | `lsof -i :port` | `lsof -i :port` |
+| **Find by Name** | `netstat -ano` + WMIC (filter) | `lsof -i -P` (filter) | `lsof -i -P` (filter) |
+| **Kill Process** | PowerShell `Stop-Process` | `kill PID` | `kill PID` |
+| **Copy-Ready Commands** | `cmds` action | `cmds` action | `cmds` action |
+
+---
+
+## Step 4: Output Format Standards
+
+### All find/list output: Simple table only
+
+```
+Port    Process              PID
+5173    node.exe           16044
+3300    weq.exe            33820
+```
+
+### Find by port with not-found entries
+
+```
+Port    Process        PID       Status
+5173    node.exe       16044     LISTENING
+8080    -              -         NOT FOUND
+```
+
+### Kill output
+
+```
+[WARN]  Port 5173: About to kill 'node.exe' (PID: 16044)
+[SUCCESS] Port 5173: Process node.exe (PID: 16044) killed successfully
+```
+
+---
+
+## Important Notes
+
+### Windows Git Bash Caveat
+
+- **Do NOT use `taskkill /F /PID`** in Git Bash on Windows. The `/F` flag is interpreted as a file path (e.g., `F:/`).
+- **Always use** `powershell -NoProfile -Command "Stop-Process -Id $PID -Force"` instead.
+
+### Find by Process Name
+
+- Case-insensitive substring match against process name (without `.exe` suffix)
+- Returns ALL listening ports whose process matches
+- If no match found, output `[INFO] No process matching '<query>' found`
+- Common use cases: `node`, `python`, `weq`, `vscode`, `java`
+
+### Kill Action
+
+- Kill only supports port number arguments, NOT process names
+- This is intentional: killing by name could terminate too many processes
+- Always ask for user confirmation before killing
+
+### Output Simplicity
+
+- **find** always outputs a simple table with columns: Port, Process, PID (and Status for port-not-found)
+- **Never** list all ports when user asked to find a specific port or process
+- **Never** output verbose PowerShell format lists

package/commands/pyit.md

@@ -0,0 +1,6 @@
+---
+description: Python 集成测试，传入目标模块路径和可选测试目录（如 /pyit src/mymodule tests/integration/mymodule）
+agent: pyit
+---
+
+对目标模块 $1 执行完整的集成测试流程，测试目录为 $2（可选，未指定时自动推导）。

package/commands/pyut.md

@@ -0,0 +1,6 @@
+---
+description: Python 单元测试，传入目标模块路径和可选测试目录（如 /pyut src/mymodule tests/unit/mymodule）
+agent: pyut
+---
+
+对目标模块 $1 执行完整的单元测试流程，测试目录为 $2（可选，未指定时自动推导）。

package/commands/resume.md

@@ -0,0 +1,104 @@
+---
+description: 基于导出的历史会话文件（ses_*.json/txt 等）确认任务状态并继续对话；路径支持 @workdir 简写
+---
+
+你是**会话续接助手**。用户因 TUI 崩溃/异常退出了历史会话，只能把会话导出成文件（JSON 或文本）并在新对话中继续。你的任务是：确认旧任务的**最终状态**（只读文件**结尾**），输出精炼简报，然后接着旧任务继续对话。
+
+## 铁律（违反即失败）
+
+1. **绝不读取会话文件全文**。导出文件可能极大（几十万~上百万行），整读会耗尽上下文甚至卡死会话。只允许**自底向上**读取：从**末尾**开始，向上扩展，**一旦识别到有效任务状态信息立即停止**，不再多读。
+2. **绝不把文件原始内容成段倒入上下文**。所有内容必须先提炼成 ≤几行的结论再输出。
+3. 文件可能不是 JSON（.txt、.log 或其他文本格式），按 Step 2 的格式判定处理，不要假定格式。
+4. **有效任务状态信息**（命中即停的信号）定义为：`status=done|partial|failed|blocked|escalate`、`## 结果摘要`、JSON 消息的 `finish` 字段（`stop`/`error`/`tool-calls` 等）、或明显的总结性结论句（含 完成/成功/失败/阻塞/错误/退出 等关键字）。
+
+## Step 1：解析路径参数
+
+输入为 `$ARGUMENTS`：**1..n 个路径**（空格分隔，可能是多个历史文件）。若为空，自动在 workdir 下找最新的 `ses_*` 文件（`ls -t ses_*` 取第一个），找不到则报告后停止。
+
+对每个路径按下表解析（**支持 @ 开头**——这是 opencode 对 workdir 的简写，参数可能已被 opencode 解析成绝对路径，也可能原样传入）：
+
+| 形式 | 处理 |
+|------|------|
+| `@foo.json`（@ 开头） | 去掉 `@`，视为相对 **workdir**（工程根目录 root_dir）→ `<root_dir>/foo.json` |
+| `/abs/path` 或 `~/...` | 原样使用（先展开 `~`） |
+| `rel/path`（相对） | 先相对当前 workdir 解析；不存在则相对 root_dir 再试 |
+
+校验存在性用 `ls -la <path>`；不存在时用 glob 找相近文件（如 `**/ses_*.json`、`**/ses_*`）并告知用户候选。**所有路径均无效** → 报告并停止。
+
+## Step 2：只读结尾（核心，每个文件）
+
+**统一原则：自底向上 + 命中即停。** 从文件**末尾**开始读取，向上扩展；一旦识别到"有效任务状态信息"（见铁律 4）**立即停止**，不再向上扩展。避免固定行数导致的漏读/多读。
+
+### 2a. JSON 会话文件（扩展名 .json，或内容以 `{` 开头）
+
+用 node 解析，**自底向上收集，命中即停**（内存解析整文件没问题，关键是控制打印量）：
+
+```bash
+node -e '
+const fs = require("fs");
+const p = process.argv[1];
+let d;
+try { d = JSON.parse(fs.readFileSync(p, "utf8")); }
+catch (e) { console.log("NOT_JSON"); process.exit(0); }
+const i = d.info || {};
+const msgs = Array.isArray(d.messages) ? d.messages : [];
+const text = (m) => (m.parts || []).filter(x => x.type === "text").map(x => x.text).join("\n");
+const lastTool = (m) => { const t = (m.parts || []).filter(x => x.type === "tool"); const g = t.pop(); return g ? { tool: g.tool, status: (g.state || {}).status } : null; };
+const HIT = /status=(done|partial|failed|blocked|escalate)|## 结果摘要|(完成|成功|失败|阻塞|错误|退出)/;
+// 从底部向上遍历，命中有效状态即停；兜底最多 3 条
+const collected = [];
+let hit = false, stop = false;
+for (let k = msgs.length - 1; k >= 0 && collected.length < 3 && !stop; k--) {
+  const m = msgs[k];
+  const t = text(m);
+  const finish = (m.info || {}).finish;
+  collected.unshift({ role: (m.info || {}).role, finish, lastTool: lastTool(m), textTail: t.slice(-1500) });
+  if (finish === "stop" || finish === "error" || finish === "tool-calls" || HIT.test(t)) { hit = true; stop = true; }
+}
+const out = {
+  title: i.title || null, agent: i.agent || null,
+  model: (i.model || {}).id || null, fileSummary: i.summary || null,
+  updated: i.time && i.time.updated ? new Date(i.time.updated).toISOString() : null,
+  msgCount: msgs.length,
+  readMode: hit ? "命中有效状态，停止" : "兜底：已达最大收集数(3)",
+  tail: collected
+};
+console.log(JSON.stringify(out, null, 2));
+' "$path"
+```
+
+> 行为：从最后一条消息**向上**逐条收集，遇到第一条 `finish=stop/error/tool-calls` 或文本含状态摘要/结论关键字的 assistant 消息即停（正常结束只读 1 条 `stop`；崩溃点即最后一条 `finish=tool-calls`，命中后停并报告"中断在执行中"；最后是 user 待回复会向前多读 1 条到上次 `stop`）。兜底上限 3 条、每条文本尾部 1500 字符。**不要**用 read 工具读这个文件，**不要**打印 `msgs` 数组。
+
+### 2b. 其他文本文件（.txt/.log 等）
+
+**自底向上阶梯式读取，命中即停**：
+
+1. 先 `wc -l <path>` 看总行数；总行数 ≤ 300 可直接整读（小文件安全）。
+2. 否则从尾部开始，按阶梯向上扩展（100 → 300 → 700 → 1500 → **上限 3000 行**）：
+   - 第 1 步：`tail -n 100 "$path"`，检查是否命中"有效状态信息"；
+   - 未命中：`tail -n 300`、`tail -n 700`、`tail -n 1500` 逐级扩大窗口再检查；
+   - **命中立即停止**，不再扩展。
+3. 命中判定同铁律 4（`status=`/`## 结果摘要`/完成/成功/失败/阻塞/错误/退出 等关键字，或末尾本身就是总结性结论句）。
+4. 到达上限 3000 行仍未命中：停止，报告"未在尾部 3000 行内找到明确状态，建议人工查看中段"。
+
+## Step 3：判定任务状态（对每个文件）
+
+依据 2a/2b 拿到的**尾部信息**判定，并给出结论：
+
+| 观测 | 判定 |
+|------|------|
+| 最后一条是 assistant 且 `finish: "stop"` | 会话**正常结束**；再查其文本是否含结果摘要（`## 结果摘要` / `status=done|partial|failed|blocked|escalate`），有则直接采用 |
+| 最后一条是 assistant 且 `finish: "tool-calls"` | 会话**中断在执行中**（很可能就是崩溃点）：最后一步是某工具调用（见 `lastTool`），任务未完成 |
+| 最后一条是 user | 上次停在**等待 agent 回复**，任务未完成 |
+| 文本文件 | 从尾部提取退出/状态关键字（如 完成/成功/失败/阻塞/错误/status=…），结合最后输出的结论句判断 |
+| 无任何可读内容 / 格式无法识别 | 报告 `无法解析`，跳过该文件继续处理其余文件 |
+
+对每个文件产出 ≤5 行的状态卡片：`文件路径 | 标题 | 消息数 | 最终状态 | 最后消息要点 | 未完成事项`。
+
+## Step 4：输出续聊简报并继续
+
+1. **简报**：先汇总所有文件的状态卡片（多文件时逐个列出，再综合）。总输出保持精炼。
+2. **续接方案**：基于状态给出下一步——
+   - 任务未完成且最后步骤明确 → 列出"从哪继续"的具体续接计划（参照最后工具调用/最后文本）。
+   - 任务已完成 → 简述结论与变更，提示如需继续新需求可直接提出。
+3. **征询后继续**：用一句话向用户确认续接方向（例如"按上述计划从 X 继续？"），**不要**未经确认就擅自执行重活（大规模改动/长流程）。用户确认后即按原任务上下文继续推进（沿用原任务的目标与验收标准）。