@appchy/jarvis 0.1.42 → 0.1.43

package/dist/bin.js

@@ -9612,7 +9612,7 @@ import WebSocket from "ws";
 import { createRequire as createRequire2 } from "module";
 var _require = createRequire2(import.meta.url);
 var VERSION2 = _require("../package.json").version ?? "0.0.0";
-var SHA = "9d8714f";
+var SHA = "c87ba61";
 var BUILT = "2026-09-07";
 var BUILD = SHA ?? "source";
 var BUILD_LABEL = SHA ? `${VERSION2} (${SHA}${BUILT ? ` ${BUILT}` : ""})` : `${VERSION2} (source)`;

package/harness/hooks/guard.py

@@ -85,6 +85,26 @@ def _git(argv, stdin=""):
     if sub == "checkout" and rest and rest[0] in (".", "--"):
         return ("`git checkout .` discards every uncommitted change.",
                 "`git stash` keeps them.")
+    # `restore` is the modern spelling of the line above and destroys identically —
+    # git's own docs steer people to it, so covering one and not the other left the
+    # rule one synonym deep. It needs no `.`/`--` test: `restore` only ever takes
+    # paths, so there is no branch form to mistake a path for.
+    #
+    # `--staged` alone is the exception and it is a real one: that writes the index
+    # and leaves the working tree untouched, which is somebody unstaging a file.
+    # Denying it would spend the guard's authority on a safe, common command.
+    if sub == "restore" and rest:
+        touches_worktree = "--worktree" in rest or "-W" in rest or not (
+            "--staged" in rest or "-S" in rest)
+        if touches_worktree:
+            return ("`git restore` overwrites the working tree from another commit, "
+                    "discarding uncommitted changes with no reflog entry.",
+                    "`git stash` keeps them, or `git restore --staged` to unstage "
+                    "without touching the file.")
+    if sub == "stash" and rest and rest[0] == "clear":
+        return ("`git stash clear` deletes every stash on this machine at once, and "
+                "nothing prints what they were.",
+                "`git stash list` first, then `git stash drop` the one you mean.")
     return None
 
 
@@ -132,6 +152,10 @@ DENY = (_rm, _git, _sql, _fs)
 #: fine here: the cost of a false positive is one extra line of output.
 WARN = {
     "--no-verify": "skips the pre-commit hooks this repo installed on purpose",
+    # Recoverable and therefore not denied: `drop` prints the sha it dropped, so the
+    # work is reachable until it is collected. Named anyway, because the sha is only
+    # useful to somebody who noticed it go past.
+    "git stash drop": "deletes a stash — the sha it prints is the only way back",
     "npm publish": "publishes to the registry — a version number cannot be reused",
     "pnpm publish": "publishes to the registry — a version number cannot be reused",
     "terraform apply": "changes real infrastructure",

package/harness/test_work.py

@@ -2807,6 +2807,30 @@ def test_the_guard_blocks_the_unrecoverable_and_allows_everything_else():
     assert guard.check("git commit --no-verify -m x")[0] == "warn"
 
 
+def test_a_destructive_git_verb_is_covered_by_both_its_spellings():
+    # `git restore` is what git's own docs steer people to, and it destroys exactly
+    # what `git checkout --` destroys. Covering one and not the other made the rule
+    # one synonym deep, and the synonym is the one a newer hand reaches for first.
+    # Measured cost of the gap: a session in another repo ran `git checkout -- work/`
+    # here and took a 68-line rule that had never been committed.
+    guard = _load_guard()
+    for bad in ("git restore work/", "git restore .",
+                "git restore --worktree src/a.ts",
+                "git restore --staged --worktree src/a.ts",
+                "git restore --source=HEAD~1 src/a.ts",
+                "git stash clear"):
+        assert guard.check(bad)[0] == "deny", f"should have blocked: {bad}"
+
+    # `--staged` on its own writes the index and leaves the file alone — somebody
+    # unstaging, which is safe and common. Denying it would spend the guard's
+    # authority on ordinary work, and an authority-less guard protects nothing.
+    for ok in ("git restore --staged src/a.ts", "git restore -S src/a.ts"):
+        assert guard.check(ok)[0] != "deny", f"false positive: {ok}"
+
+    # Recoverable, so it is named rather than refused: `drop` prints the sha.
+    assert guard.check("git stash drop")[0] == "warn"
+
+
 def test_a_quoted_separator_does_not_switch_the_guard_off():
     # The headline hole: `re.split` cut at the `;` INSIDE the string, both halves
     # then failed to parse as unbalanced quotes, and every rule was skipped. A

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -51,13 +51,13 @@
     "vitest": "^2.1.0",
     "@jarvis/agents": "1.0.0",
     "@jarvis/anthropic": "1.0.0",
+    "@jarvis/board": "0.1.0",
+    "@jarvis/data": "0.1.0",
     "@jarvis/logger": "1.0.0",
     "@jarvis/rpc": "1.0.0",
-    "@jarvis/board": "0.1.0",
     "@jarvis/types": "1.0.0",
     "@jarvis/typescript-config": "1.0.0",
-    "@jarvis/vitest-config": "1.0.0",
-    "@jarvis/data": "0.1.0"
+    "@jarvis/vitest-config": "1.0.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",