pi-warden 1.0.0 → 1.1.1

package/CHANGELOG.md

@@ -6,6 +6,29 @@ How to keep this current: add the entry in the same pull request as the change,
 
 ## Unreleased
 
+## 1.1.1
+
+### Fixed
+
+- `scripts/live-smoke.mjs` and `scripts/security-cases.mjs` no longer crash when a verdict has no off-task answer, which is now the usual case: the acting request does not ask `off_task`, only the trace sample does. The missing value prints as `-`.
+- The three off-task cases in `scripts/security-cases.mjs` (side comment, take over previous work, new instruction overrides history) pass `traceSample: 1`, so every call asks the off-task question and the cases test its answer again.
+
+## 1.1.0
+
+### Added
+
+- `"typesafeBackend": "liquid"` sends judgments to Liquid AI (api.liquid.ai, key in `LIQUID_API_KEY`, default model `d1:free`) through pi-typesafe 0.9.0. `d1:free` is free but slow (median about 14 seconds a request against the 5-second default `timeoutMs`), and the paid `d1` counts the state once per question, so a 7-question action request costs several times what it costs on Jev; see [docs/configuration.md](docs/configuration.md#liquid-ai-backend).
+
+### Changed
+
+- pi-typesafe `^0.9.0` (was `^0.8.0`).
+
+## 1.0.1
+
+### Fixed
+
+- The run-end rules check no longer judges files that a `git pull` brought in when the pulled commit was made during the run, such as a squash commit from a pull request merged on the hosting service: a commit counts as brought by git when this worktree's HEAD reflog shows that the checkout did not create it, whatever its date. The commit-date rule stays as the fallback when the reflog is off.
+
 ## 1.0.0
 
 The first stable release. From 1.0, pi-warden follows semver for the surface the README's Versioning section lists. Coming from 0.74.1, the last release on npm: [docs/upgrading.md](docs/upgrading.md) lists the removed settings, the new defaults, and what project files may still change. The changes since 0.74.1 are in the sections 0.75.0 to 0.90.0 below, and the README's "What it costs" table gives the measured effect of each 1.0 change.

package/dist/turn-rules.d.ts

@@ -40,7 +40,7 @@ export interface TurnDiff {
     text: string;
     /** What the caps cut, named per file, so the request and the trace say what the judge does not see. */
     cuts: string[];
-    /** What the git-brought filter did beyond its plain work: it failed, or it was cut at the probe limit. */
+    /** What the git-brought filter did beyond its plain work: it failed, fell back to the date rule, or was cut at the probe limit. */
     notes: string[];
 }
 /**

package/dist/turn-rules.js

@@ -105,56 +105,133 @@ function batchCheck(lines, cwd) {
         child.stdin?.end(`${lines.join("\n")}\n`);
     });
 }
+/**
+ * Reflog reasons for a commit this checkout created: `commit` (also `(amend)`, `(merge)`, `(initial)`), `cherry-pick`,
+ * `revert`, `am`, a rebase step that picks or rewrites a commit, and a `merge` or `pull` that made a merge commit. A fast-forward,
+ * a reset, a checkout, and the start and finish of a rebase only move HEAD to commits made elsewhere or earlier.
+ */
+const CREATING_REFLOG_SUBJECT = /^(?:(?:commit|cherry-pick|revert|am)\b|(?:merge|pull)\b[^:]*: Merge made by |[^:]*\((?:pick|reword|squash|fixup|continue|edit|merge)\):)/;
+const REFLOG_OFF = new Set(["false", "no", "off", "0", "never"]);
+/**
+ * The commits this checkout created since the run began, from the HEAD reflog of this worktree. Undefined when the
+ * reflog is turned off or cannot be read, or does not account for the move to `endHead`: the caller then uses the date rule.
+ * An entry counts as written during the run when its second is the start second or later. The reflog has whole seconds,
+ * so in the start second the oldest entry that names the start HEAD is taken as the move that put HEAD there, and it
+ * and everything older are not the run's.
+ */
+async function createdInRun(cwd, start, endHead) {
+    try {
+        let setting = "";
+        try {
+            setting = (await git(["config", "--get", "core.logAllRefUpdates"], cwd, 5000)).trim().toLowerCase();
+        }
+        catch { /* unset: the default keeps the reflog on */ }
+        if (REFLOG_OFF.has(setting))
+            return undefined;
+        const startSecond = Math.floor(start.startedAt / 1000);
+        const lines = (await git(["reflog", "show", "--date=unix", `--since=${startSecond}`, "--format=%H%x09%gd%x09%gs", "HEAD"], cwd)).split("\n").filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            const match = /^([0-9a-f]{40,64})\t[^\t]*@\{(\d+)\}\t(.*)$/.exec(line);
+            if (!match)
+                return undefined;
+            const entry = { commit: match[1], at: Number(match[2]), subject: match[3] };
+            if (entry.at < startSecond)
+                break;
+            entries.push(entry);
+        }
+        for (let index = entries.length - 1; index >= 0; index--) {
+            if (entries[index].at === startSecond && entries[index].commit === start.head) {
+                entries.length = index;
+                break;
+            }
+        }
+        // HEAD moved, so a reflog that is recording has the move as its newest entry.
+        if (entries[0]?.commit !== endHead)
+            return undefined;
+        return [...new Set(entries.filter(entry => CREATING_REFLOG_SUBJECT.test(entry.subject)).map(entry => entry.commit))];
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * The changed files that git itself brought in: HEAD moved during the run (a pull, a merge), and the file has no
- * uncommitted change at the end and holds, byte for byte, its content in a commit the end HEAD reaches, the start
- * HEAD does not reach, and that was committed before the run began. A file the agent edited, changed with an
- * uncommitted command (`git checkout <old> -- file` included), or committed in the run is never in this set.
+ * uncommitted change at the end, holds, byte for byte, its content in a commit the end HEAD reaches and the start HEAD
+ * does not, that this checkout did not create during the run (the commit date does not matter: a squash commit the
+ * hosting service makes mid-run counts), and no commit this checkout created during the run introduced that content.
+ * A commit introduces a path's content when that content differs from the path's content in each of its parents.
+ * A file the agent edited, changed with an uncommitted command (`git checkout <old> -- file` included), or committed in
+ * the run is never in this set. When the HEAD reflog is off or unreadable, a commit counts only when it was committed
+ * before the run began (the 0.87.0 rule) and the trace says so.
  * At most `BROUGHT_PROBE_LIMIT` file × commit pairs are probed: with more, only the newest commits that fit are probed,
  * since the newest commit holding a path has the content of every path no later commit changed. A git failure is
- * returned in the note, and the caller judges every file.
+ * returned in the notes, and the caller judges every file.
  */
 async function broughtByGit(cwd, start, endTree, paths) {
     const brought = new Set();
+    const notes = [];
     if (!start.head || !paths.length)
-        return { brought };
-    let note;
+        return { brought, notes };
+    const startHead = start.head;
     try {
         const endHead = await commitOf("HEAD", cwd);
-        if (!endHead || endHead === start.head)
-            return { brought };
-        // `--before` keeps a commit whose committer date is at or before the stamp; one second earlier makes it strict.
-        const before = Math.floor(start.startedAt / 1000) - 1;
-        let older = (await git(["rev-list", endHead, `^${start.head}`, `--before=${before} +0000`], cwd)).split("\n").filter(Boolean);
+        if (!endHead || endHead === startHead)
+            return { brought, notes };
+        const created = await createdInRun(cwd, { ...start, head: startHead }, endHead);
+        let older;
+        if (created) {
+            const made = new Set(created);
+            older = (await git(["rev-list", endHead, `^${startHead}`], cwd)).split("\n").filter(commit => commit && !made.has(commit));
+        }
+        else {
+            notes.push("git-brought filter used the commit-date rule because the HEAD reflog is off or cannot be read: a commit made after the run began counts as the agent's");
+            // `--before` keeps a commit whose committer date is at or before the stamp; one second earlier makes it strict.
+            const before = Math.floor(start.startedAt / 1000) - 1;
+            older = (await git(["rev-list", endHead, `^${startHead}`, `--before=${before} +0000`], cwd)).split("\n").filter(Boolean);
+        }
         if (!older.length)
-            return { brought };
+            return { brought, notes };
         const uncommitted = new Set((await git(["diff", "--name-only", "--no-renames", "-z", endHead, endTree, "--"], cwd)).split("\0").filter(Boolean));
         const clean = paths.filter(path => !uncommitted.has(path));
         if (!clean.length)
-            return { brought };
-        const fit = Math.floor(BROUGHT_PROBE_LIMIT / clean.length);
+            return { brought, notes };
+        // Each created commit is probed in itself and in its parents; one line of `--parents` output is the commit then its parents.
+        const makers = created?.length ? (await git(["rev-list", "--no-walk", "--parents", ...created], cwd)).split("\n").filter(Boolean).map(line => line.split(" ")) : [];
+        const makerProbes = makers.reduce((sum, ids) => sum + ids.length, 0);
+        const fit = Math.max(0, Math.floor(BROUGHT_PROBE_LIMIT / clean.length) - makerProbes);
         if (fit < older.length) {
-            note = `git-brought filter cut: ${clean.length} files × ${older.length} older commits is over the ${BROUGHT_PROBE_LIMIT}-probe limit, so only the newest ${fit} commits were probed`;
+            notes.push(`git-brought filter cut: ${clean.length} files × ${older.length} older commits is over the ${BROUGHT_PROBE_LIMIT}-probe limit, so only the newest ${fit} commits were probed`);
             older = older.slice(0, fit);
             if (!older.length)
-                return { brought, note };
+                return { brought, notes };
         }
-        const probes = clean.flatMap(path => [`${endHead}:${path}`, ...older.map(commit => `${commit}:${path}`)]);
+        const probes = clean.flatMap(path => [`${endHead}:${path}`, ...older.map(commit => `${commit}:${path}`), ...makers.flatMap(ids => ids.map(commit => `${commit}:${path}`))]);
         const answers = await batchCheck(probes, cwd);
-        const stride = older.length + 1;
+        const stride = 1 + older.length + makerProbes;
         clean.forEach((path, row) => {
-            const atEnd = answers[row * stride];
+            const base = row * stride;
+            const atEnd = answers[base];
             if (!atEnd)
                 return;
-            if (older.some((_, column) => answers[row * stride + 1 + column] === atEnd))
-                brought.add(path);
+            if (!older.some((_, column) => answers[base + 1 + column] === atEnd))
+                return;
+            let at = base + 1 + older.length;
+            for (const ids of makers) {
+                const inCommit = answers[at] === atEnd;
+                const inParents = ids.slice(1).some((_, parent) => answers[at + 1 + parent] === atEnd);
+                at += ids.length;
+                if (inCommit && !inParents)
+                    return;
+            }
+            brought.add(path);
         });
     }
     catch (error) {
         // Nothing is skipped on a git failure: the caller judges every file, and the trace says the filter failed.
-        return { brought: new Set(), note: `git-brought filter failed: ${(error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim()}; every changed file was judged` };
+        return { brought: new Set(), notes: [...notes, `git-brought filter failed: ${(error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim()}; every changed file was judged`] };
     }
-    return note ? { brought, note } : { brought };
+    return { brought, notes };
 }
 /**
  * The working-tree change since the snapshot: the files git reports and each one's unified diff, capped per file and
@@ -178,7 +255,7 @@ export async function diffSince(cwd, startTree, maxChars, start) {
     for (let index = 0; index + 1 < names.length; index += 2)
         if (names[index + 1])
             candidates.push(names[index + 1]);
-    const { brought, note } = start ? await broughtByGit(cwd, start, endTree, candidates) : { brought: new Set(), note: undefined };
+    const { brought, notes } = start ? await broughtByGit(cwd, start, endTree, candidates) : { brought: new Set(), notes: [] };
     for (let index = 0; index + 1 < names.length; index += 2) {
         const status = names[index].slice(0, 1);
         const path = names[index + 1];
@@ -217,7 +294,7 @@ export async function diffSince(cwd, startTree, maxChars, start) {
         cuts.push(`${file.path}: file diff cut to ${room} chars to fit the ${maxChars}-char total; later files not sent`);
         spent = true;
     }
-    return { files, text: chunks.join("\n"), cuts, notes: note ? [note] : [] };
+    return { files, text: chunks.join("\n"), cuts, notes };
 }
 // ---------------------------------------------------------------------------
 // The turn question: one Choice per turn rule, against the whole diff and the task.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-warden",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Makes the Pi agent follow your project's rules. Jev judges every write against your pi-warden.md and quotes the broken rule back to the agent, names slop, breaks stuck loops, calls out unverified done claims, compresses large tool output, and holds the rare destructive command. Built on pi-typesafe.",
   "type": "module",
   "license": "MIT",
@@ -88,6 +88,6 @@
     "typescript": "^6.0.0"
   },
   "dependencies": {
-    "pi-typesafe": "^0.8.0"
+    "pi-typesafe": "^0.9.0"
   }
 }