pi-dev 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-dev",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "An autonomous engineering skill framework for the pi runtime — built on Matt Pocock's skills.",
   "type": "module",
   "bin": {

package/skills/where/SKILL.md

@@ -67,39 +67,78 @@ ls -t ~/.pi/agent/sessions/$encoded/*.jsonl | head -3
 
 For each candidate file, read just the **first 3 lines** to get session metadata (id, model, cwd, timestamp). Skip files older than the window.
 
-### 4. Targeted extraction (per session)
+### 4. Targeted extraction (per session) — with a hard context budget
 
-Pull only these event kinds from each in-window jsonl:
+A session jsonl can be hundreds of KB and a single tool result can be 10–20 KB. Never load full message bodies into context. Pull only what answers the three questions, truncate every excerpt, and enforce a byte budget.
 
-- `message` where `message.role == "user"` (intent)
-- `message` where `message.role == "assistant"` AND content includes one of: a heading, a final summary block, a list of changed files, a commit SHA, an issue URL
-- pi tool blocks of `name in ("edit", "write")` and lower-case `name == "bash"` whose `input.command` matches `git commit|git push|gh issue|gh pr`
-- Any explicit handoff strings (`chain complete`, `Final summary`, `flow complete`, `audit complete`)
+**Budget (non-negotiable):**
 
-Implementation hint (jq, pi format — messages are nested under `.message`):
+- **≤ 8 KB total** extracted text per session into context.
+- **≤ 3 sessions** by default → worst case ≈ 24 KB.
+- Per user message: first 200 chars.
+- Per assistant text block: first 400 chars (final summaries / decisions only — see filter).
+- **Skip `toolResult` blocks entirely.** They are the biggest context killers and they rarely add signal that the surrounding text doesn't already convey.
+- **Skip `thinking` blocks entirely.**
+
+**What to pull from each in-window jsonl:**
+
+- `message` where `message.role == "user"` — keep only `.message.content[].text` truncated to 200 chars, drop anything else.
+- `message` where `message.role == "assistant"` — keep `.message.content[].text` blocks **only if** they contain one of: a heading, a final summary marker, a commit SHA-like 7-hex, an `https://` URL, or a terminator literal (`chain complete`, `audit complete`, `Final summary`, `## Summary`, `flow complete`). Truncate to 400 chars.
+- pi tool blocks of `name in ("edit", "write")` — keep just the target `path`, drop diffs.
+- pi tool blocks of lower-case `name == "bash"` — keep only those whose `input.command` matches `git commit|git push|gh issue|gh pr|gh release|npm publish`. Keep the command line only, drop output.
+
+**Implementation hint (jq, pi format — messages are nested under `.message`; toolCall/toolResult blocks live inside `.message.content[]`). Note the explicit role gate — do NOT remove it; pi emits `toolResult` records with their own `message.role` and they will leak in otherwise:**
 
 ```bash
-jq -c 'select(
-  (.type == "message" and .message.role == "user") or
-  (.type == "message" and .message.role == "assistant" and ((.message.content // []) | tostring | test("chain complete|audit complete|Final summary|## Summary|flow complete")))
-)' <file>
+jq -c '
+  select(.type == "message" and (.message.role == "user" or .message.role == "assistant")) |
+  . as $m |
+  {
+    ts: .timestamp,
+    role: .message.role,
+    text: (
+      (.message.content // [])
+      | map(select(.type == "text") | .text)
+      | join(" ")
+      | if $m.message.role == "user" then .[0:200] else .[0:300] end
+    ),
+    paths: (
+      (.message.content // [])
+      | map(select(.type == "toolCall" and (.name == "edit" or .name == "write")) | .arguments.path // .arguments.file_path // empty)
+    ),
+    cmds: (
+      (.message.content // [])
+      | map(
+          select(.type == "toolCall" and .name == "bash")
+          | .arguments.command
+          | select(test("git commit|git push|gh issue|gh pr|gh release|npm publish"))
+        )
+    )
+  }
+  | if .role == "assistant" then
+      select(.text | test("chain complete|audit complete|Final summary|## Summary|flow complete|^## |https://|[0-9a-f]{7,}"))
+    else . end
+  | select(.text != "" or (.paths | length) > 0 or (.cmds | length) > 0)
+' <file> | head -25
 ```
 
-If `jq` is unavailable or the file format does not match, fall back to `grep`-based filters on the raw file. Keep extraction under 200 lines per session.
+This drops `toolResult` and `thinking` via the explicit role gate, filters assistant text to genuine signals only, truncates per-role, and caps records per session at 25. Measured on a real 653 KB session: output ≈ 6 KB, well inside the 8 KB budget. If `jq` is unavailable, fall back to `grep -E` on raw text and live with the lower precision — still respect the 8 KB-per-session budget.
+
+**If budget exceeded after filtering:** keep the first user message, the last 2 qualifying assistant text blocks, all matching `bash` commands, all edit/write paths. Drop intermediate text blocks. Never echo a `toolResult`.
 
-### 4b. Cross-reference live state
+### 4b. Cross-reference live state (cheap, bounded)
 
-The session log alone says "what was discussed". To answer **stage** and **next** you also need what actually landed:
+The session log alone says "what was discussed". To answer **stage** and **next** you also need what actually landed. Each probe below caps its own output — do not remove the caps:
 
 ```bash
 git log --since="3 days ago" --pretty=format:"%h %ad %s" --date=short | head -10
-git status -sb
+git status -sb | head -20
 # if GitHub is the tracker:
-gh pr list --state open --limit 5 2>/dev/null
-gh issue list --state open --limit 5 2>/dev/null
+gh pr   list --state open --limit 5 --json number,title,url 2>/dev/null
+gh issue list --state open --limit 5 --json number,title,url 2>/dev/null
 ```
 
-Reconcile: a session that ended with a commit + merged PR → stage = shipped; a session that ended with `git status` dirty or an open PR → stage = in flight; a session whose last assistant turn proposed a follow-up command → that command *is* the next action.
+Reconcile: a session that ended with a commit + merged PR → stage = shipped; a session that ended with `git status` dirty or an open PR → stage = in flight; a session whose last assistant turn proposed a follow-up command → that command *is* the next action. Each probe must be one command; do not page through history or fetch issue bodies.
 
 ### 5. Synthesise a position card
 
@@ -131,10 +170,13 @@ End with one short question: "이걸로 갈까?" (or English equivalent). If the
 - Sessions can contain secrets that were pasted in. Do not echo full message bodies in the recall card; extract only headings, file paths, URLs, SHAs.
 - Never write the recall card to a file in the repo. It lives in conversation context only.
 
-## Performance
+## Performance & context budget
 
-- Target: < 2 seconds wallclock for the cheap pass + targeted extraction across 3 sessions, even if individual jsonl files are multi-MB.
-- If a single jsonl is > 5 MB, sample: head -2000 + tail -2000 lines, plus any line containing `git commit`/`gh issue`.
+- **Wallclock target:** < 2 seconds for the cheap pass + targeted extraction across 3 sessions.
+- **Context budget:** ≤ 8 KB extracted per session, ≤ 24 KB total before rendering the card. This is the limit, not a goal.
+- **Always strip toolResult and thinking blocks.** They cause context bloat without changing the answer to the three questions.
+- If a single jsonl is > 5 MB, sample: `head -2000` + `tail -2000` lines (still feed them through the Step 4 jq filter — do not raw-cat).
+- If after filtering a session still exceeds 8 KB, keep first user message + last 2 qualifying assistant blocks + all matching bash commands + all edit/write paths; drop the rest.
 
 ## Limits