pi-task-tracker 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Page
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# pi-task-tracker
+
+Task workflow tracking for the [pi coding agent](https://www.npmjs.com/package/@earendil-works/pi-coding-agent): every completed task becomes a real git commit on your branch, and those commits double as interactive rollback checkpoints.
+
+## What it does
+
+- **TODO.md tracking** — each prompt is recorded as a task entry in `TODO.md` and checked off when the agent settles.
+- **README.md maintenance** — the project structure section stays up to date with agent-created files.
+- **Per-task git auto-commit** — when a task completes, only the files the agent actually touched are staged and committed with the task as the message. Nothing else is swept in.
+- **`/rollback`** — pick any prior commit interactively and the working tree is restored to that point. Worktree-only, nothing is committed, fully reversible (`git diff` to review, commit when satisfied).
+
+### What makes it different
+
+- **Hashline-aware** — records edits made through `pi-hashline-edit-pro`'s `replace`/`insert` tools, not just the native `edit` tool (most setups that replace native edit would otherwise go completely untracked).
+- **Shell-aware** — captures files created/modified by `bash` **and** `powershell` tool calls via before/after `git status` diffing.
+- **Nested-repo aware** — changes inside a sub-repository (a `.git` below your session root) are committed *there* — the innermost repo wins — and never pollute the outer repo.
+- **Subagent-safe** — `.pi-subagents/` session artifacts are never recorded, listed, or committed.
+- **~zero per-turn cost** — one incremental `git add` of touched files per task; no full-worktree scans, no background snapshot daemons.
+
+## /rollback
+
+```
+/rollback
+  → pick a commit (sha, date, task subject)
+  → review the impact summary (files restored / removed, dirty-worktree warning)
+  → confirm → working tree restored to that commit
+```
+
+Conservative by design: the index is untouched, the rollback itself is never auto-committed, and untracked files are out of scope (they were never committed, so their provenance is unknown).
+
+## Configuration
+
+Optional `taskTracker` key in `~/.pi/agent/settings.json` (all default to `true`):
+
+```json
+{
+  "taskTracker": {
+    "todo": true,
+    "readme": true,
+    "autoCommit": true
+  }
+}
+```
+
+- `todo` — maintain `TODO.md`
+- `readme` — maintain the `README.md` project-structure section
+- `autoCommit` — per-task commits; these are the `/rollback` checkpoints, so disabling this also disables rollback targets
+
+## Requirements
+
+- [pi coding agent](https://www.npmjs.com/package/@earendil-works/pi-coding-agent) with the extension API
+- `git` on PATH
+- Works with or without `pi-hashline-edit-pro`
+
+## Limitations
+
+- Rollback granularity is per **task** (agent turn-set), not per message. If you need message-level time travel including your own manual edits, a snapshot-based extension is a better fit — at the cost of full-worktree scans every turn.
+- Files created by shell commands inside a nested repo that was never touched via write/edit during the session are not captured.
+- An embedded (unregistered) sub-repo shows as `?? dir/` in the outer `git status` — that's standard git behavior; this extension never stages it.
+
+## 本简介（中文）
+
+`pi-task-tracker` 为 pi coding agent 提供任务级工作流跟踪：每次任务完成时，agent 实际改动的文件被自动提交到你的分支（提交信息即任务名），这些提交同时构成检查点；`/rollback` 可交互式地把工作区回滚到任意历史提交（仅工作区、不自动提交、可逆）。支持 hashline 编辑工具、bash/powershell 产物捕获、嵌套仓库归属最内层、自动排除 `.pi-subagents/` 会话数据。配置项见上方 `taskTracker`。
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,561 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  isBashToolResult,
+  isPowerShellToolResult,
+  isToolCallEventType,
+} from "@earendil-works/pi-coding-agent";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+
+function ts(): string {
+  return new Date().toISOString().slice(0, 19).replace("T", " ");
+}
+
+// ---- Git version control helpers ----
+// spawnSync bypasses the shell, so commit messages with any characters
+// (quotes, $, backticks) are safe on both Windows and Unix.
+function git(args: string[], cwd: string): string {
+  try {
+    const r = spawnSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    return r.status === 0 ? (r.stdout || "").trim() : "";
+  } catch {
+    return "";
+  }
+}
+
+function gitOk(args: string[], cwd: string): boolean {
+  try {
+    return spawnSync("git", args, { cwd, stdio: "ignore" }).status === 0;
+  } catch {
+    return false;
+  }
+}
+
+// Snapshot of working-tree changes (untracked + modified, gitignore-respecting).
+// Returns Map<relativePath, porcelainStatus>. Used to diff what a bash command
+// changed: tool_call fires before execution, tool_result after.
+function gitStatusSet(cwd: string): Map<string, string> {
+  // NOTE: do not use the trimming git() helper here -- .trim() strips the leading
+  // space of the first porcelain line (e.g. " M path"), corrupting the 2-char
+  // status field and shifting the path by one. Read stdout raw instead.
+  let out = "";
+  try {
+    const r = spawnSync("git", ["-c", "core.quotepath=false", "status", "--porcelain", "-uall"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    out = r.status === 0 ? r.stdout || "" : "";
+  } catch {
+    return new Map();
+  }
+  const m = new Map<string, string>();
+  for (const line of out.split("\n")) {
+    if (line.length < 3) continue;
+    const status = line.slice(0, 2);
+    let p = line.slice(3);
+    const arrow = p.indexOf(" -> ");
+    if (arrow !== -1) p = p.slice(arrow + 4);
+    if (p.startsWith('"') && p.endsWith('"')) {
+      try { p = JSON.parse(p); } catch {}
+    }
+    if (p) m.set(p.replace(/\\/g, "/"), status);
+  }
+  return m;
+}
+
+// Subagent working data (inputs/outputs/transcripts/mission metadata) is
+// session machinery, not project content: never record, list or commit it.
+const SUBAGENT_DIR = ".pi-subagents";
+
+function isSubagentPath(rel: string): boolean {
+  const p = rel.replace(/\\/g, "/");
+  return p === SUBAGENT_DIR || p.startsWith(SUBAGENT_DIR + "/");
+}
+
+// Nearest enclosing git worktree root for an absolute path, searching upward
+// from the file's own directory and stopping at the session cwd (guaranteed a
+// repo by initGit). A .git found below cwd (nested/embedded repository) wins,
+// so changes made inside sub-repositories are attributed to the innermost
+// repo's history instead of polluting the outer one.
+function ownerRepoRoot(absPath: string, cwd: string): string {
+  let dir = path.dirname(absPath);
+  for (;;) {
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    const rel = path.relative(dir, cwd);
+    if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return cwd;
+    const parent = path.dirname(dir);
+    if (parent === dir) return cwd;
+    dir = parent;
+  }
+}
+
+function ensureGitIdentity(cwd: string): void {
+  // ensure local identity so commits never fail on a fresh machine
+  if (!git(["config", "user.name"], cwd)) {
+    gitOk(["config", "user.name", "Pi Agent"], cwd);
+  }
+  if (!git(["config", "user.email"], cwd)) {
+    gitOk(["config", "user.email", "pi-agent@local"], cwd);
+  }
+}
+
+const GITIGNORE_SEED =
+  "node_modules/\n.env\n.env.*\n*.log\n.DS_Store\n__pycache__/\n*.pyc\n.pi/\n.pi-subagents/\ndist/\nbuild/\n";
+
+function initGit(cwd: string): void {
+  // 1. init repo if absent
+  if (!fs.existsSync(path.join(cwd, ".git"))) {
+    gitOk(["init"], cwd);
+  }
+  ensureGitIdentity(cwd);
+  // 2. seed a sensible .gitignore if none exists
+  const gi = path.join(cwd, ".gitignore");
+  if (!fs.existsSync(gi)) {
+    fs.writeFileSync(gi, GITIGNORE_SEED, "utf-8");
+  } else if (!fs.readFileSync(gi, "utf-8").split(/\r?\n/).some((l) => l.trim() === ".pi-subagents/")) {
+    // existing repos: make sure subagent working data stays untracked
+    const prev = fs.readFileSync(gi, "utf-8");
+    fs.writeFileSync(gi, prev.replace(/\n*$/, "\n\n") + ".pi-subagents/\n", "utf-8");
+  }
+}
+
+// Stage only agent-touched files + workflow trackers (TODO.md / README.md),
+// then commit one snapshot per completed task.
+// Nested repositories: files are grouped by their owning git repo (nearest
+// enclosing .git). Changes inside a sub-repo are committed THERE (innermost
+// repo wins) and never staged in the outer repo; subagent working data
+// (.pi-subagents/) is never committed at all.
+function gitCommitTask(
+  cwd: string,
+  task: string | null,
+  created: string[],
+  edited: string[]
+): void {
+  const groups = new Map<string, Set<string>>();
+  const consider = (relPath: string) => {
+    if (isSubagentPath(relPath)) return;
+    const abs = path.resolve(cwd, relPath);
+    if (path.relative(cwd, abs).startsWith("..") || path.isAbsolute(path.relative(cwd, abs))) return;
+    const root = ownerRepoRoot(abs, cwd);
+    const rel = path.relative(root, abs).replace(/\\/g, "/");
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return;
+    if (!groups.has(root)) groups.set(root, new Set());
+    groups.get(root)!.add(rel);
+  };
+  for (const f of created) consider(f);
+  for (const f of edited) consider(f);
+  if (!groups.has(cwd)) groups.set(cwd, new Set());
+  const rootFiles = groups.get(cwd)!;
+  rootFiles.add("TODO.md");
+  rootFiles.add("README.md");
+  rootFiles.add(".gitignore");
+
+  const subject = task ? task.slice(0, 72) : "chore: workflow auto-commit";
+  const visible = (f: string) => !isSubagentPath(f);
+  for (const [root, files] of groups) {
+    ensureGitIdentity(root);
+    for (const f of files) {
+      gitOk(["add", "--", f], root);
+    }
+    // skip when nothing ended up staged in this repo
+    if (!git(["diff", "--cached", "--name-only"], root)) continue;
+    const parts: string[] = [];
+    if (root === cwd) {
+      if (created.some(visible)) parts.push(`Created: ${created.filter(visible).join(", ")}`);
+      if (edited.some(visible)) parts.push(`Edited: ${edited.filter(visible).join(", ")}`);
+    }
+    const args = ["commit", "-m", subject];
+    if (parts.length > 0) args.push("-m", parts.join("\n"));
+    gitOk(args, root);
+  }
+}
+
+// Best-effort: bring an existing TODO up to the standard format (ensure header).
+function normalizeTodo(todoPath: string): void {
+  try {
+    const content = fs.readFileSync(todoPath, "utf-8");
+    if (!content.trimStart().startsWith("# TODO")) {
+      fs.writeFileSync(todoPath, "# TODO\n\n" + content, "utf-8");
+    }
+  } catch {}
+}
+
+// Best-effort: bring an existing README up to the standard format (ensure sections).
+function normalizeReadme(readmePath: string, name: string): void {
+  try {
+    let content = fs.readFileSync(readmePath, "utf-8");
+    let changed = false;
+
+    // remove legacy "## Recent Changes" log section (rule: no logs in README)
+    const rcHeader = "## Recent Changes";
+    const rcIdx = content.indexOf(rcHeader);
+    if (rcIdx !== -1) {
+      const nextSection = content.indexOf("\n## ", rcIdx + rcHeader.length);
+      if (nextSection !== -1) {
+        content = content.slice(0, rcIdx) + content.slice(nextSection + 1);
+      } else {
+        content = content.slice(0, rcIdx).trimEnd() + "\n";
+      }
+      changed = true;
+    }
+
+    if (!content.includes("## Overview")) {
+      content = content.trimEnd() + "\n\n## Overview\n\nTODO: Add project description.\n";
+      changed = true;
+    }
+    if (!content.includes("## Project Structure")) {
+      content = content.trimEnd() + `\n\n## Project Structure\n\n\`\`\`\n${name}/\n\`\`\`\n`;
+      changed = true;
+    }
+    if (changed) {
+      fs.writeFileSync(readmePath, content, "utf-8");
+    }
+  } catch {}
+}
+
+// ---- Configuration ----
+// Optional `taskTracker` key in ~/.pi/agent/settings.json (env
+// PI_CODING_AGENT_DIR respected). All flags default to true.
+//   { "taskTracker": { "todo": true, "readme": true, "autoCommit": true } }
+//   todo       - maintain TODO.md (task entries, completion bookkeeping)
+//   readme     - maintain README.md (structure section updates)
+//   autoCommit - per-task git commits; these commits are the /rollback
+//                checkpoints, so disabling it also disables rollback targets
+interface TrackerConfig {
+  todo: boolean;
+  readme: boolean;
+  autoCommit: boolean;
+}
+
+function readConfig(): TrackerConfig {
+  try {
+    const dir = process.env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".pi", "agent");
+    const raw = JSON.parse(fs.readFileSync(path.join(dir, "settings.json"), "utf-8"));
+    const t = raw.taskTracker && typeof raw.taskTracker === "object" ? raw.taskTracker : {};
+    return {
+      todo: t.todo !== false,
+      readme: t.readme !== false,
+      autoCommit: t.autoCommit !== false,
+    };
+  } catch {
+    return { todo: true, readme: true, autoCommit: true };
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  let todoPath = "";
+  let readmePath = "";
+  let cwd = "";
+  let config: TrackerConfig = readConfig();
+  let currentTask: string | null = null;
+  const createdFiles: string[] = [];
+  const editedFiles: string[] = [];
+  // toolCallId -> pre-run git status snapshot, so tool_result can diff to
+  // toolCallId -> pre-run git status snapshot per repo root (cwd + every nested
+  // repo discovered this session), so tool_result can diff to capture files
+  // created/edited by bash scripts (write/edit listeners miss these).
+  const beforeStatus = new Map<string, Map<string, Map<string, string>>>();
+  // nested repository roots (inner repos below cwd) seen so far this session
+  const nestedRoots = new Set<string>();
+  // learn the owning repo of a touched path and remember nested roots
+  const watchRootFor = (absPath: string) => {
+    const root = ownerRepoRoot(absPath, cwd);
+    if (root !== cwd) nestedRoots.add(root);
+  };
+  const snapshotAll = (): Map<string, Map<string, string>> => {
+    const m = new Map<string, Map<string, string>>();
+    m.set(cwd, gitStatusSet(cwd));
+    for (const root of nestedRoots) m.set(root, gitStatusSet(root));
+    return m;
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    cwd = ctx.cwd;
+    config = readConfig();
+    todoPath = config.todo ? path.join(cwd, "TODO.md") : "";
+    readmePath = config.readme ? path.join(cwd, "README.md") : "";
+    readmePath = path.join(cwd, "README.md");
+    currentTask = null;
+    nestedRoots.clear();
+    createdFiles.length = 0;
+    editedFiles.length = 0;
+
+    if (!fs.existsSync(todoPath)) {
+      fs.writeFileSync(todoPath, "# TODO\n\n", "utf-8");
+    } else {
+      // try to bring an existing TODO up to standard format
+      normalizeTodo(todoPath);
+    }
+
+    if (!fs.existsSync(readmePath)) {
+      const name = path.basename(cwd);
+      fs.writeFileSync(
+        readmePath,
+        `# ${name}\n\n## Overview\n\nTODO: Add project description.\n\n## Project Structure\n\n\`\`\`\n${name}/\n\`\`\`\n`,
+        "utf-8"
+      );
+    } else if (readmePath) {
+      // try to bring an existing README up to standard format
+      normalizeReadme(readmePath, path.basename(cwd));
+    }
+
+    // bootstrap git (safe on existing repos: only sets missing config/.gitignore)
+    if (config.autoCommit) initGit(cwd);
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    const prompt = event.prompt;
+    if (!prompt || !prompt.trim() || !todoPath) return;
+
+    const task = prompt.trim().replace(/\n/g, " ").slice(0, 200);
+    currentTask = task;
+
+    const line = `- [ ] ${task} _(${ts()})_\n`;
+    fs.appendFileSync(todoPath, line, "utf-8");
+  });
+
+  pi.on("tool_call", async (event) => {
+    if (!cwd) return;
+
+    if (isToolCallEventType("write", event)) {
+      const p = event.input.path as string;
+      if (p) {
+        const rel = path.relative(cwd, p);
+        if (rel && !rel.startsWith("..") && !isSubagentPath(rel)) {
+          watchRootFor(path.resolve(cwd, p));
+          if (!fs.existsSync(p)) {
+            createdFiles.push(rel.replace(/\\/g, "/"));
+          }
+        }
+      }
+    }
+
+    // Edit-like tools: the native "edit" tool plus pi-hashline-edit-pro's
+    // "replace"/"insert" (hashline replaces the native edit tool, so without
+    // this, hashline edits would go unrecorded and never be committed).
+    // Both hashline tools carry the target file in input.path; native edit
+    // uses filePath || path.
+    if (event.toolName === "edit" || event.toolName === "replace" || event.toolName === "insert") {
+      const p = (event.input.filePath || event.input.path) as string;
+      if (p) {
+        const rel = path.relative(cwd, p);
+        if (rel && !rel.startsWith("..") && !isSubagentPath(rel) && !editedFiles.includes(rel)) {
+          watchRootFor(path.resolve(cwd, p));
+          editedFiles.push(rel.replace(/\\/g, "/"));
+        }
+      }
+    }
+
+    // shell tools: snapshot working-tree state BEFORE execution so tool_result
+    // can diff. Covers bash and (on Windows) powershell.
+    if (isToolCallEventType("bash", event) || isToolCallEventType("powershell", event)) {
+      try {
+        beforeStatus.set(event.toolCallId, snapshotAll());
+      } catch {}
+    }
+  });
+
+  // After a bash command finishes, diff the working tree against the pre-run
+  // snapshot and record new/modified files. This captures files produced by
+  // scripts (node/python/shell) that the write/edit listeners cannot see.
+  pi.on("tool_result", async (event) => {
+    if (!cwd) return;
+    if (!isBashToolResult(event) && !isPowerShellToolResult(event)) return;
+    const before = beforeStatus.get(event.toolCallId);
+    beforeStatus.delete(event.toolCallId);
+    if (!before) return;
+    const after = snapshotAll();
+    for (const [root, afterSet] of after) {
+      const beforeSet = before.get(root) ?? new Map<string, string>();
+      for (const [p, status] of afterSet) {
+        const prev = beforeSet.get(p);
+        if (prev === status) continue; // unchanged by this command
+        if (p === "TODO.md" || p === "README.md") continue; // handled at commit time
+        // Normalize to a cwd-relative path. Inner-repo entries come relative
+        // to the inner root and need rebasing onto cwd.
+        let rel = p;
+        if (root !== cwd) {
+          rel = path.relative(cwd, path.join(root, p)).replace(/\\/g, "/");
+          if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) continue;
+        }
+        // Guard: never track paths outside cwd (git status emits "../" paths
+        // when cwd is a subdirectory of a parent repo), nor subagent data.
+        if (p === ".." || p.startsWith("../") || path.isAbsolute(p)) continue;
+        if (isSubagentPath(rel)) continue; // subagent session data is never tracked
+        if (prev === undefined) {
+          // newly appeared in the working tree
+          if (status[0] === "?" || status[1] === "?") {
+            if (!createdFiles.includes(rel)) createdFiles.push(rel);
+          } else {
+            if (!editedFiles.includes(rel)) editedFiles.push(rel);
+          }
+        } else {
+          // status changed (e.g. clean -> modified, or modified -> deleted) => edited
+          if (!editedFiles.includes(rel)) editedFiles.push(rel);
+        }
+      }
+    }
+  });
+
+  // Baseline reset on /tree navigation (same-session rewind).
+  // pi-rewind-hook may restore files to an earlier point when the user
+  // navigates the session tree. File records accumulated before the
+  // navigation no longer reflect the worktree, so drop them instead of
+  // staging stale/reverted paths into the next task's commit.
+  // NOTE: /fork, /resume and /new switch to a different session file and
+  // re-fire session_start, which already resets everything — /tree is the
+  // only navigation that stays inside the same session.
+  // currentTask is kept on purpose: an in-flight task entry in TODO.md
+  // must still be closed out at agent_settled.
+  // Conservative by design: the rollback diff is NOT auto-committed here
+  // (it could swallow the user's own manual edits); it simply remains as
+  // uncommitted worktree state for the user/agent to commit deliberately.
+  pi.on("session_tree", async (_event, _ctx) => {
+    createdFiles.length = 0;
+    editedFiles.length = 0;
+    beforeStatus.clear();
+  });
+
+  pi.on("agent_settled", async (_event, _ctx) => {
+    const taskSnapshot = currentTask;
+    currentTask = null;
+    if (taskSnapshot && config.todo && todoPath && fs.existsSync(todoPath)) {
+      try {
+        const content = fs.readFileSync(todoPath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = lines.length - 1; i >= 0; i--) {
+          if (lines[i].includes("- [ ]")) {
+            lines.splice(i, 1); // delete the completed TODO entry
+            break;
+          }
+        }
+        fs.writeFileSync(todoPath, lines.join("\n"), "utf-8");
+      } catch {}
+    }
+
+    if (config.readme && readmePath && fs.existsSync(readmePath)) {
+      try {
+        let content = fs.readFileSync(readmePath, "utf-8");
+        let changed = false;
+
+        if (createdFiles.length > 0) {
+          const marker = "```\n";
+          const structIdx = content.indexOf("## Project Structure");
+          if (structIdx !== -1) {
+            const closeIdx = content.indexOf(marker, structIdx + "## Project Structure".length);
+            if (closeIdx !== -1) {
+              const insertPos = closeIdx + marker.length;
+              const newLines = createdFiles
+                .filter((f) => !content.includes(f))
+                .map((f) => `├── ${f}\n`)
+                .join("");
+              if (newLines) {
+                content = content.slice(0, insertPos) + newLines + content.slice(insertPos);
+                changed = true;
+              }
+            }
+          } else {
+            // no structure section yet: add one in standard format
+            const section = `## Project Structure\n\n\`\`\`\n${createdFiles
+              .map((f) => `├── ${f}\n`)
+              .join("")}\`\`\`\n`;
+            content = content.trimEnd() + "\n\n" + section;
+            changed = true;
+          }
+        }
+
+        if (changed) {
+          fs.writeFileSync(readmePath, content, "utf-8");
+        }
+      } catch {}
+    }
+
+    // commit a snapshot of this task's changes (fresh and existing repos alike)
+    if (cwd && config.autoCommit) {
+      gitCommitTask(cwd, taskSnapshot, createdFiles, editedFiles);
+    }
+
+    createdFiles.length = 0;
+    editedFiles.length = 0;
+    beforeStatus.clear();
+  });
+
+  // ── /rollback: restore the working tree to a previous commit ──────────
+  // Task commits (one per completed task, subject = task name) double as a
+  // checkpoint chain. This command restores WORKING TREE files to any prior
+  // commit — deliberately conservative:
+  //   - worktree only (index untouched), nothing is auto-committed;
+  //   - the rollback itself is reversible (git diff / git checkout .);
+  //   - untracked files are out of scope (never committed, unknown provenance).
+  // Replaces pi-rewind-hook for the common case at ~zero per-turn cost.
+  pi.registerCommand("rollback", {
+    description: "Roll the working tree back to a previous commit (worktree-only, nothing is committed; task commits are the checkpoints)",
+    handler: async (_args, ctx) => {
+      if (!cwd) return;
+      if (!fs.existsSync(path.join(cwd, ".git"))) {
+        ctx?.ui.notify("Not a git repository - nothing to roll back", "warning");
+        return;
+      }
+
+      // 1. list recent commits as rollback targets
+      const log = git(["log", "--max-count=30", "--date=format:%m-%d %H:%M", "--format=%h|%ad|%s"], cwd);
+      if (!log) {
+        ctx?.ui.notify("No commits yet - nothing to roll back", "warning");
+        return;
+      }
+      const entries = log.split("\n").map((l) => {
+        const [sha, date, ...rest] = l.split("|");
+        return { sha, label: `${sha} ${date} ${rest.join("|").slice(0, 58)}` };
+      });
+      if (!ctx?.hasUI) {
+        ctx?.ui.notify("/rollback requires interactive mode. Recent commits:\n" + entries.map((e) => e.label).join("\n"), "info");
+        return;
+      }
+      const chosen = await ctx.ui.select("Roll back to which commit?", entries.map((e) => e.label));
+      if (!chosen) return; // cancelled
+      const target = entries.find((e) => e.label === chosen);
+      if (!target) return;
+
+      // 2. what changed between target and HEAD (rename pairs split into A+D)
+      const diff = git(["diff", "--name-status", "--no-renames", `${target.sha}..HEAD`], cwd);
+      const restores: string[] = [];
+      const removes: string[] = [];
+      for (const line of diff.split("\n")) {
+        const tab = line.indexOf("\t");
+        if (tab === -1) continue;
+        const status = line.slice(0, tab).trim()[0];
+        const file = line.slice(tab + 1).trim();
+        if (!file || file.includes("->")) continue;
+        // never touch subagent session data
+        if (isSubagentPath(file)) continue;
+        if (status === "A") removes.push(file);
+        else if (status === "M" || status === "D") restores.push(file);
+      }
+      if (restores.length === 0 && removes.length === 0) {
+        ctx.ui.notify("No tracked file changes since the target commit - nothing to roll back", "info");
+        return;
+      }
+
+      // 3. confirm — warn about uncommitted changes that would be overwritten
+      const dirty = git(["status", "--porcelain"], cwd).split("\n").filter(Boolean).length;
+      const summary = `Restore ${restores.length} file(s) and remove ${removes.length} file(s), back to ${target.sha}${dirty > 0 ? ` (WARNING: ${dirty} uncommitted change(s) in the worktree - affected paths will be overwritten)` : " (clean worktree)"}`;
+      const ok = await ctx.ui.select(`${summary}. Proceed? (worktree only, nothing is committed)`, ["Cancel", "Roll back"]);
+      if (ok !== "Roll back") return;
+
+      // 4. apply (worktree only; chunked for Windows command-length limits)
+      for (let i = 0; i < restores.length; i += 50) {
+        gitOk(["restore", "--source=" + target.sha, "--worktree", "--", ...restores.slice(i, i + 50)], cwd);
+      }
+      for (const f of removes) {
+        try {
+          fs.rmSync(path.join(cwd, f), { force: true });
+        } catch {}
+      }
+
+      // 5. drop accumulated file records — they no longer reflect the worktree
+      createdFiles.length = 0;
+      editedFiles.length = 0;
+      beforeStatus.clear();
+      ctx.ui.notify(`Rolled back to ${target.sha} - worktree updated, nothing committed. Review with git diff, then commit when satisfied.`, "info");
+    },
+  });
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "pi-task-tracker",
+  "version": "0.1.1",
+  "description": "Task workflow tracking for the pi coding agent: TODO/README maintenance, per-task git auto-commits as checkpoints, and an interactive /rollback. Hashline-aware, nested-repo aware, subagent-artifact-safe.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "coding-agent",
+    "git",
+    "todo",
+    "rollback",
+    "checkpoint",
+    "auto-commit",
+    "workflow"
+  ],
+  "author": "Page",
+  "license": "MIT",
+  "files": [
+    "index.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}