pi-task-tracker 0.1.1 → 0.1.3

package/README.md

@@ -7,13 +7,13 @@ Task workflow tracking for the [pi coding agent](https://www.npmjs.com/package/@
 - **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).
+- **`/rollback`** — pick any prior commit interactively and the working tree is restored to that point **while the conversation rewinds to the turn that produced it** (one checkpoint for files *and* context). Worktree-only, nothing is committed, fully reversible (`git diff` to review, commit when satisfied). Old session branches are preserved — `/tree` can navigate back.
 
 ### 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.
+- **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. The outer task commit records anchors (`Nested: <repo>@<sha>`), so `/rollback` restores nested repos to their exact matching commit.
 - **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.
 
@@ -26,7 +26,7 @@ Task workflow tracking for the [pi coding agent](https://www.npmjs.com/package/@
   → 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).
+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). Conversation rewind reuses pi's session-tree navigation, so nothing is ever deleted from the session file.
 
 ## Configuration
 
@@ -60,7 +60,7 @@ Optional `taskTracker` key in `~/.pi/agent/settings.json` (all default to `true`
 
 ## 本简介（中文）
 
-`pi-task-tracker` 为 pi coding agent 提供任务级工作流跟踪：每次任务完成时，agent 实际改动的文件被自动提交到你的分支（提交信息即任务名），这些提交同时构成检查点；`/rollback` 可交互式地把工作区回滚到任意历史提交（仅工作区、不自动提交、可逆）。支持 hashline 编辑工具、bash/powershell 产物捕获、嵌套仓库归属最内层、自动排除 `.pi-subagents/` 会话数据。配置项见上方 `taskTracker`。
+`pi-task-tracker` 为 pi coding agent 提供任务级工作流跟踪：每次任务完成时，agent 实际改动的文件被自动提交到你的分支（提交信息即任务名），这些提交同时构成检查点；`/rollback` 可交互式地把工作区回滚到任意历史提交，**同时把对话上下文回退到产生该提交的任务轮次**（文件与上下文同一检查点；仅工作区、不自动提交、可逆，旧会话分支保留可 /tree 回访）。支持 hashline 编辑工具、bash/powershell 产物捕获、嵌套仓库归属最内层、自动排除 `.pi-subagents/` 会话数据。配置项见上方 `taskTracker`。
 
 ## License
 

package/index.ts

@@ -151,23 +151,35 @@ function gitCommitTask(
 
   const subject = task ? task.slice(0, 72) : "chore: workflow auto-commit";
   const visible = (f: string) => !isSubagentPath(f);
-  for (const [root, files] of groups) {
+  // Inner repos commit first, the session repo last, so the outer commit can
+  // carry anchors ("Nested: <rel>@<sha>") pointing at the exact nested-repo
+  // commits of this task - /rollback uses them for precise restoration.
+  const innerCommits: string[] = [];
+  const orderedRoots = [...groups.keys()].filter((r) => r !== cwd);
+  orderedRoots.push(cwd);
+  for (const root of orderedRoots) {
+    const files = groups.get(root)!;
     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 staged = git(["diff", "--cached", "--name-only"], root);
+    if (!staged && !(root === cwd && innerCommits.length > 0)) 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(", ")}`);
+      for (const ic of innerCommits) parts.push(`Nested: ${ic}`);
     }
     const args = ["commit", "-m", subject];
     if (parts.length > 0) args.push("-m", parts.join("\n"));
-    gitOk(args, root);
+    if (!staged) args.push("--allow-empty");
+    if (gitOk(args, root) && root !== cwd) {
+      const rel = path.relative(cwd, root).replace(/\\/g, "/");
+      innerCommits.push(`${rel}@${git(["rev-parse", "--short", "HEAD"], root)}`);
+    }
+  }
   }
-}
 
 // Best-effort: bring an existing TODO up to the standard format (ensure header).
 function normalizeTodo(todoPath: string): void {
@@ -212,6 +224,74 @@ function normalizeReadme(readmePath: string, name: string): void {
   } catch {}
 }
 
+// ---- Rollback helpers ----
+// Compute the worktree actions needed to bring `root`'s tracked files back to
+// `sha`: restores (M/D paths) and removes (A paths). Subagent data excluded.
+function repoDiffActions(root: string, sha: string): { restores: string[]; removes: string[] } {
+  const diff = git(["diff", "--name-status", "--no-renames", `${sha}..HEAD`], root);
+  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;
+    if (isSubagentPath(file)) continue;
+    if (status === "A") removes.push(file);
+    else if (status === "M" || status === "D") restores.push(file);
+  }
+  return { restores, removes };
+}
+
+// Apply actions computed by repoDiffActions (worktree only; chunked for
+// Windows command-length limits).
+function applyRepoRollback(root: string, sha: string, actions: { restores: string[]; removes: string[] }): void {
+  for (let i = 0; i < actions.restores.length; i += 50) {
+    gitOk(["restore", "--source=" + sha, "--worktree", "--", ...actions.restores.slice(i, i + 50)], root);
+  }
+  for (const f of actions.removes) {
+    try {
+      fs.rmSync(path.join(root, f), { force: true });
+    } catch {}
+  }
+}
+
+// Find the commit in a nested repo matching the rolled-back task. One task
+// produces commits with the SAME subject in every repo it touched, so match
+// by subject AND occurrence ordinal (task names may repeat over time):
+// outerIndexNewer = how many commits with this subject are newer than the
+// outer target; pick the same ordinal (newest-first) in the nested history.
+function findInnerTarget(root: string, subject: string, outerDateISO: string): string | null {
+  const log = git(["log", "--max-count=200", "--format=%H|%cI|%s"], root);
+  if (!log) return null;
+  const outerDate = Date.parse(outerDateISO);
+  if (Number.isNaN(outerDate)) return null;
+  let best: { sha: string; t: number } | null = null;
+  for (const line of log.split("\n")) {
+    if (!line) continue;
+    const [sha, date, ...rest] = line.split("|");
+    if (rest.join("|") !== subject) continue;
+    const t = Date.parse(date);
+    if (Number.isNaN(t) || t > outerDate) continue;
+    if (!best || t > best.t) best = { sha, t };
+  }
+  return best ? best.sha : null;
+}
+// ---- Session helpers ----
+// Flatten an AgentMessage's content to plain text (string or content blocks).
+function messageText(m: { content?: unknown }): string {
+  const c = (m as { content?: unknown }).content;
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) {
+    return c
+      .filter((b) => b && typeof b === "object" && (b as { type?: string }).type === "text")
+      .map((b) => String((b as { text?: string }).text ?? ""))
+      .join(" ");
+  }
+  return "";
+}
+
 // ---- Configuration ----
 // Optional `taskTracker` key in ~/.pi/agent/settings.json (env
 // PI_CODING_AGENT_DIR respected). All flags default to true.
@@ -515,47 +595,103 @@ export default function (pi: ExtensionAPI) {
       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);
+      // 2. what changed between target and HEAD in the session repo (rename
+      // pairs split into A+D), plus every nested repo touched this session:
+      // one task commits the same subject in each repo it touched, so nested
+      // repos roll back to their own matching commit (time-aligned).
+      const actions = repoDiffActions(cwd, target.sha);
+      const innerRollbacks: { root: string; sha: string; name: string; restores: number; removes: number }[] = [];
+      const innerApply: { root: string; sha: string; actions: { restores: string[]; removes: string[] } }[] = [];
+      if (nestedRoots.size > 0) {
+        // exact anchors recorded in the outer commit body: Nested: <rel>@<sha>
+        const body = git(["show", "-s", "--format=%B", target.sha], cwd);
+        const anchored = new Map<string, string>();
+        for (const line of body.split("\n")) {
+          const m = /^Nested: (.+)@([0-9a-f]{7,40})$/.exec(line.trim());
+          if (m) anchored.set(m[1], m[2]);
+        }
+        const subject = target.subject || git(["show", "-s", "--format=%s", target.sha], cwd);
+        const outerDate = git(["show", "-s", "--format=%cI", target.sha], cwd);
+        for (const root of nestedRoots) {
+          const rel = path.relative(cwd, root).replace(/\\/g, "/");
+          const innerSha = anchored.get(rel) || findInnerTarget(root, subject, outerDate);
+          if (!innerSha) continue;
+          const a = repoDiffActions(root, innerSha);
+          if (a.restores.length > 0 || a.removes.length > 0) {
+            innerRollbacks.push({ root, sha: innerSha, name: path.basename(root), restores: a.restores.length, removes: a.removes.length });
+            innerApply.push({ root, sha: innerSha, actions: a });
+          }
+        }
       }
-      if (restores.length === 0 && removes.length === 0) {
+      const totalRestores = actions.restores.length + innerRollbacks.reduce((n, r) => n + r.restores, 0);
+      const totalRemoves = actions.removes.length + innerRollbacks.reduce((n, r) => n + r.removes, 0);
+      if (totalRestores === 0 && totalRemoves === 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
+      // 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 scope = [`main repo: restore ${actions.restores.length}, remove ${actions.removes.length}`];
+      for (const r of innerRollbacks) scope.push(`${r.name}: restore ${r.restores}, remove ${r.removes}`);
+      const summary = `Back to ${target.sha} - ${scope.join('; ')}${dirty > 0 ? ` (WARNING: ${dirty} uncommitted change(s) - 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 {}
+      // 4. apply everywhere (worktree only)
+      applyRepoRollback(cwd, target.sha, actions);
+      for (const r of innerApply) {
+        applyRepoRollback(r.root, r.sha, r.actions);
       }
 
       // 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");
+
+      // 6. rewind the conversation to the turn that produced this commit, so
+      // context and files land on the same checkpoint. The task commit's
+      // subject is the (normalized) user prompt, so match the last user
+      // message starting with it, then the end of that turn. Old entries stay
+      // in the session tree — /tree can navigate back at any time.
+      let conversationNote = "";
+      try {
+        const subject = git(["show", "-s", "--format=%s", target.sha], cwd);
+        if (subject && ctx.sessionManager) {
+          const norm = (t: string) => t.replace(/\s+/g, " ").trim();
+          const branch = ctx.sessionManager.getBranch();
+          let userIdx = -1;
+          for (let i = branch.length - 1; i >= 0; i--) {
+            const e = branch[i] as { type?: string; message?: { role?: string; content?: unknown } };
+            if (e.type !== "message" || e.message?.role !== "user") continue;
+            if (norm(messageText(e.message as { content?: unknown })).startsWith(norm(subject))) {
+              userIdx = i;
+              break;
+            }
+          }
+          if (userIdx !== -1) {
+            // end of that turn = last entry before the next user message
+            let end = userIdx;
+            for (let j = userIdx + 1; j < branch.length; j++) {
+              const e = branch[j] as { type?: string; message?: { role?: string } };
+              if (e.type === "message" && e.message?.role === "user") break;
+              end = j;
+            }
+            const targetId = branch[end].id;
+            const nav = ctx.navigateTree
+              ? await ctx.navigateTree(targetId, { label: `rollback → ${target.sha}` })
+              : { cancelled: false };
+            if (!nav.cancelled) {
+              conversationNote = " Conversation rewound to that point (/tree can navigate back).";
+            }
+          } else {
+            conversationNote = " (No matching conversation entry found - context unchanged.)";
+          }
+        }
+      } catch {
+        conversationNote = " (Conversation rewind failed - files were rolled back.)";
+      }
+      ctx.ui.notify(`Rolled back to ${target.sha} - worktree updated, nothing committed. Review with git diff, then commit when satisfied.${conversationNote}`, "info");
     },
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-task-tracker",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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",