@appchy/jarvis 0.1.84 → 0.1.85

package/harness/work.py

@@ -79,7 +79,6 @@ Subcommands:
     wrap [--task <name>]           finish a session cleanly: what a machine knows
                                    about this run, then what to do. Writes NOTHING
     coverage [--feature <name>]    what a RUN proved vs what features promise
-    migrate-owner [--force]        rename `product:` -> `owner:` across tasks
 
 The unattended loop — a schedule calls `next`, and the rest exists so a run that
 cannot finish has somewhere to put the reason instead of stalling or guessing:
@@ -143,7 +142,7 @@ from harness import ids
 from harness.architecture import (cmd_domain_new, cmd_init, cmd_rules, cmd_system_new,
                                   cmd_where)
 from harness.coverage import cmd_coverage
-from harness.report import cmd_align, cmd_list, cmd_migrate_owner, cmd_readme
+from harness.report import cmd_align, cmd_list, cmd_readme
 from harness.wrap import cmd_wrap
 from harness.config import (DEFAULTS, ConfigError, apply, cmd_applies, cmd_config,
                             cmd_context, cmd_method, cmd_remind, resolve)
@@ -166,7 +165,7 @@ SUBCOMMANDS = (
     "epic-new", "feature-new", "version-new", "place", "handoff", "release", "archive",
     "find", "list", "readme", "move", "plan", "session", "kickoff", "path", "code",
     "domain-new", "system-new", "where", "rules", "align", "wrap", "coverage",
-    "migrate", "migrate-owner", "next", "status", "drop", "ask", "answer", "needs", "verify",
+    "migrate", "next", "status", "drop", "ask", "answer", "needs", "verify",
     "observed", "log", "digest", "sync",
 )
 
@@ -192,27 +191,32 @@ def parse_argv(argv):
 
 
 def _project_root(flags) -> Path:
-    """The repo the harness is acting on. `--project` wins, then the env, then the
-    cwd — the same precedence `find_work_root` uses, so config and tree can never
-    disagree about which repo this is.
-
-    The last step WALKS UP, and that is the half this claimed and did not do. The
-    tree search walks up for a `work/`; this stopped at the cwd, so standing one
-    directory into a repo found no config and every check ran in the shipped
-    dialect against the right tree. Measured here: `align` from the root reported
-    twenty citations, and from `apps/cli/` reported thirteen entirely different
-    ones, having stopped recognising this repo's own ids altogether. One tree, two
-    answers, decided by where the caller happened to be standing.
+    """The repo the harness is acting on: `--project`, else the repo the WORK TREE
+    was found in, else the env, else the cwd.
+
+    **It asks the tree search rather than re-reading the environment**, and that is
+    the whole of it. This used to consult the same two variables in the OPPOSITE
+    order — `CLAUDE_PROJECT_DIR` first, `WORK_DIR` second — while claiming in this
+    docstring to match the tree search. With both set at once, which they are under
+    Claude Code, config resolved from one repo while the tree being mutated was in
+    another: every id, every standard and every gate ran in a dialect the tree's
+    own repo never chose. One question about which repo this is, asked once.
+
+    The fallbacks are what keeps `init` and `doctor` working on a repo that has no
+    tree yet — there is nothing for the search to find, so the env and then the cwd
+    answer instead. And the cwd step WALKS UP: standing one directory into a repo
+    used to find no config at all, so `align` from the root reported twenty
+    citations and from `apps/cli/` thirteen entirely different ones.
     """
     import os
-    p = flags.get("project") or os.environ.get("CLAUDE_PROJECT_DIR")
+    p = flags.get("project")
     if p:
         return Path(p).resolve()
-    wd = os.environ.get("WORK_DIR")
-    if wd:
-        return Path(wd).resolve().parent
     root, _, cur = locate_work_root()
-    return root.parent if root else cur
+    if root:
+        return root.parent
+    project = os.environ.get("CLAUDE_PROJECT_DIR")
+    return Path(project).resolve() if project else cur
 
 
 def main() -> int:
@@ -272,22 +276,23 @@ def main() -> int:
         cfg = copy.deepcopy(DEFAULTS)
         apply(cfg)
 
-    # A command a hook fires before every edit must never reach the commit below.
-    # It would put a network round trip on the hot path, and — worse — it would land
-    # whatever half-written board edits the session happened to have open at that
-    # moment, at a moment nobody chose. These read the tree and write nothing into it
-    # but gitignored per-session markers, so there is nothing of their own to carry.
-    if cmd in _HOOK_PATH or not git.enabled():
+    # THE COMMIT BELONGS TO A COMMAND THAT CHANGES THE BOARD, and to nothing else
+    # (founder, 2026-09-10). Every other command — `list`, `status`, `where`,
+    # `context`, `align`, and the two a Claude Code hook fires — only looks, so it
+    # has nothing of its own to land. They used to drive the commit anyway, from a
+    # `finally:` that ran for all of them: what got committed was whatever the
+    # person happened to have open in `work/` at that moment, filed as
+    # "docs(work): board edits" under no item, at a moment nobody chose. The pull
+    # was already scoped this way; now both halves ask the same question.
+    if cmd not in git.WRITES or not git.enabled():
         return dispatch(cmd, pos, flags, cfg)
 
-    # Pull → write → commit → push. The commit is what makes the write unloseable,
-    # so it runs in a `finally`: a command that mutated the tree and then exited
-    # non-zero has still changed the board, and leaving that uncommitted is exactly
-    # the hole this closes.
+    # Pull → write → commit → push. The commit runs in a `finally`: a command that
+    # mutated the tree and then exited non-zero has still changed the board, and
+    # leaving that uncommitted is exactly the hole this closes.
     root = locate_work_root()[0]
     repo = root.parent if root else _project_root(flags)
-    if cmd in git.WRITES:
-        _say(git.refresh(repo))
+    _say(git.refresh(repo))
     try:
         return dispatch(cmd, pos, flags, cfg)
     finally:
@@ -298,9 +303,8 @@ def main() -> int:
         # whole seam exists to close.
         rows = events.pending()
         # The item is what an event names, or what the command was given. A command
-        # with neither — `align` sweeping up somebody's hand edit to the tree — names
-        # NO item, rather than putting a command name where four other slices expect
-        # an item.
+        # with neither names NO item, rather than putting a command name where four
+        # other slices expect an item.
         item = rows[0]["name"] if rows else (pos[0] if pos else "")
         committed, pushed, note = git.land(repo, item, rows)
         if committed:
@@ -321,21 +325,6 @@ def _say(note: str) -> None:
         sys.stderr.flush()
 
 
-#: Commands a HOOK fires rather than a person, and which therefore run at a moment
-#: nobody picked. They are kept clear of the commit that every other command drives:
-#: a hook is not a decision to publish the board.
-#:
-#: NOT folded into `_READS`, though every name here is in it. That set is "commands
-#: that only look", and one of its members is `align`, which is deliberately expected
-#: to sweep up somebody's hand edit and commit it — the commit site says so in as many
-#: words. Reusing it would turn a read-set into a commit-policy and change that
-#: behaviour silently. `remind` has the same shape as this one and is deliberately
-#: left out: it fires once at the end of a turn rather than before every edit, and
-#: whether the Stop hook should be committing the board is a question somebody should
-#: answer on purpose rather than have settled as a side effect of this.
-_HOOK_PATH = {"applies"}
-
-
 #: Commands that only LOOK. `--branch` is meaningful on these and refused on every
 #: other, which is the safe default: a command added later is covered without anyone
 #: remembering to come back here.
@@ -506,8 +495,6 @@ def dispatch(cmd, pos, flags, cfg) -> int:
         return cmd_coverage(flags)
     if cmd == "migrate":
         return cmd_migrate(flags)
-    if cmd == "migrate-owner":
-        return cmd_migrate_owner(flags)
 
     # --- the unattended loop -------------------------------------------------
     # `next` is the entry point a schedule calls; everything else here exists so

package/package.json

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