@appchy/jarvis 0.1.36 → 0.1.39

package/harness/work.py

@@ -0,0 +1,534 @@
+"""
+jarvis work — deterministic mechanics for the work coding harness.
+
+Work lives at <repo>/work/, in three tiers — version, epic, task — beside the
+nine org-domains that hold every kind of durable call. There is NO central
+ledger: a durable rule lives in the domain or system that owns it, and
+`where <id>` resolves any id to its home.
+
+    work/
+    ├── ROADMAP.md                                 the release sequence
+    ├── product/<feature>.md                       what the app does   (B-nn · AC-nn)
+    ├── architecture/<system>.md                   how it is built     (hosted rules)
+    ├── design/ quality/ security/ operations/     the remaining domains,
+    │   support/ commercial/ legal/                each hosting its own rules
+    ├── versions/<v>/version.md                    a RELEASE — permanent record
+    │   └── <epic>/epic.md                         the plan-it-together doc; removed at release
+    │       └── {queue,in-progress,complete}/<task>/
+    └── backlog/<epic>/<task>/                     epics planned but not yet in a cut
+
+A VERSION is a release: it states a user-visible `outcome:` and cannot open
+while an earlier one is unreleased. An EPIC is temporary — the coherent goal
+planned together, archived at release. A TASK is ONE goal, end-to-end,
+internally phased, and always belongs to an epic.
+
+A task's status is the bucket it sits in — never a frontmatter field; a backlog
+task has none until pulled, which is why the backlog has no buckets. A version's
+status is derived. Names are globally unique across all three tiers, so a name
+alone resolves anywhere — `place` dispatches on what the name IS.
+
+WHAT IS DERIVED, and therefore never written by hand: the `code:` region
+vocabulary (the union of what the systems declare) · work/README.md's table ·
+architecture/README.md and its dependency map · the rules constraining a
+task (`task.code ∩ system.code`). If a fact can be computed it is not stored.
+
+Subcommands:
+    version-new <v> --outcome "…" [--title ...] [--order N]
+                    [--start|--end|--target DATE] [--design] [--architecture]
+    epic-new <name> [--version <v>] [--title ...] [--covers <feature>/AC-01,…]
+             [--owner <feature>|<domain>]   domain = it moves no product criterion
+             [--continues <epic>]           carries on an epic from an earlier cut
+    task-new <name> --epic <e> [--priority P0|P1|P2] [--tier 0-3] [--title ...]
+             [--depends a,b] [--owner <feature>|<domain>] [--code region,region]
+             [--covers AC-01,AC-02] [--start|--end DATE]
+    feature-new <feature> [--state idea|defined|building|shipped]
+    domain-new <name>              system-new <name> --code region,region
+    place <name> --version <v> [--epic <e>]   which CUT it lives in — from
+          <name> --backlog --epic <e>         anywhere, to anywhere
+                                   an EPIC moves whole; a task needs --epic
+    move <name> <queue|in-progress|complete>
+    handoff <name>                 plan <name> [--file <path>]
+    session <name> [--id <uuid>]   the current session, or one this one STARTED
+    kickoff <name> [--next "…"] [--watch "…"] [--prompt-only]
+                                   the opening prompt for the NEXT session, derived —
+                                   and how to start it where `session.mcp` names a server
+    release <v>                    archive <v> [--dry-run]
+    init [--project <dir>]         scaffold work/ + the nine domains (idempotent)
+    doctor [--project <dir>]       runtime, config, tree, ids, graph — self-diagnosis
+    id-new --host <name> --title "…"   claim the next free rule id, atomically
+    config [--project <dir>]       the merged config, as one JSON object
+    config set <key> <value> [--json]      write one dotted key, validated first
+    config unset <key>                     drop an override, back to the default
+    context [--project <dir>]      the SessionStart pointers, all config-derived
+    remind --used <tokens> [--session <id>]   wrap up yet? one JSON object, or
+                                   nothing. Takes a MEASUREMENT: how full a
+                                   session is, is its client's to answer
+    applies --file <path> [--session <id>]    what a session must be told now that
+                                   it is about to write this file — the judgements
+                                   no gate catches, and which system it is in
+    list · readme · path <name> · code <region>
+    where <id>                     id -> home, code:, enforced_by, citation count
+    find <name|branch|#pr>         where work is being done — branch and PR, both ways
+    list --branch <ref>            the board as another branch has it (read-only)
+    rules --task <name>            what constrains a task, derived
+    align [--class <name>]         every misalignment class; REPORT-ONLY, exit 0
+    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:
+
+    next [--instance <id>] [--peek]    take ONE task and claim it; prints the read order
+    status                             what shipped · what waits on you · what is at risk
+    method                             the METHOD in full — how work is done here. The session
+                                       block names it; this is the body, on request.
+    verify [--task <name>] [--async]   RUN verify.* (shell=False) and record the result;
+                                       --async starts them and returns, then reports
+                                       progress and finally the result. One at a time
+                                       per checkout: two corrupt each other.
+    observed <task> --ac AC-01 --saw "…"   an eyes-on, for what a test cannot prove
+    ask <task> --question "…" [--options "a | b"] [--owner who] [--durable]
+                                       park a question, move on — exits 0, never blocks
+    needs                              every open question, oldest first
+    answer <task> --choose "…"         resolve it and put the task back to work
+    drop <name> [--why "…"]            give a claim back
+    log [--since DATE] [--task <n>] · digest [--since DATE]
+    sync                               pull the board fresh; send anything unpushed
+
+Where `git.commit` is set, a board write PULLS, WRITES, COMMITS and PUSHES, and the
+commit's own trailers are the record — there is no work/.events.jsonl. Off by
+default: the harness is shared, and a repo that never asked must not start
+committing. `sync` is the read-only fresh pull, and the recovery for a push that
+could not land at the time.
+
+`move <name> complete` is a GATE, not a warning: it refuses unless the criteria are
+checked, `verify` passed at the current commit, and every `covers:` criterion has
+coverage or a recorded eyes-on. `--accept "<reason>" --owner <name>` overrides it,
+as a recorded event with somebody's name on it — never silently.
+
+Every mutating command regenerates work/README.md and architecture/README.md,
+then prints lint warnings — there is no manual step.
+
+`align` is deliberately non-blocking. With coverage partial a blocking gate
+would be permanently red, and a lint that is always red is one nobody reads;
+the flip to blocking is its own task, once coverage is real.
+
+The session id comes from CLAUDE_CODE_SESSION_ID (a silent no-op outside Claude
+Code). work/ is located by walking up from the cwd; WORK_DIR overrides.
+"""
+
+import copy
+import sys
+from pathlib import Path
+
+# The entry ORCHESTRATES; it does not implement (a file grows into a folder,
+# and the entry keeps the domain name). Every mechanic lives in a `harness/` module
+# named for its noun — `harness/task.py`, `harness/align.py` — so adding a
+# subcommand means adding it there plus one line below, never growing this file.
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from harness.tree import die, locate_work_root
+from harness import events, git
+from harness.task import cmd_code, cmd_handoff, cmd_move, cmd_new, cmd_path, cmd_place, cmd_plan, cmd_session
+from harness.epic import cmd_epic_new
+from harness.version import cmd_archive, cmd_release, cmd_version_new
+from harness.product import cmd_feature_new
+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.wrap import cmd_wrap
+from harness.config import (DEFAULTS, ConfigError, apply, cmd_applies, cmd_config,
+                            cmd_context, cmd_method, cmd_remind, resolve)
+from harness.safety import cmd_doctor, cmd_id_new
+from harness.autonomy import cmd_answer, cmd_ask, cmd_digest, cmd_log, cmd_needs
+from harness.shift import cmd_drop, cmd_next, cmd_status
+from harness.gate import cmd_observed, cmd_verify
+from harness.kickoff import cmd_kickoff
+from harness.git import cmd_sync
+from harness.branches import cmd_find
+
+
+#: Every subcommand the ladder in `main` dispatches, in the order it tries them.
+#: Hand-written prose here drifted from the ladder and told callers that `new`
+#: was expected while nothing dispatched it — so this is the ONE list, and
+#: `test_work.py` fails when it stops matching what `main` actually handles.
+SUBCOMMANDS = (
+    "config", "method", "context", "remind", "applies", "init", "doctor", "id-new", "task-new", "new",
+    "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-owner", "next", "status", "drop", "ask", "answer", "needs", "verify",
+    "observed", "log", "digest", "sync",
+)
+
+
+def parse_argv(argv):
+    """Tiny flag parser: positionals + `--flag value` pairs."""
+    pos, flags = [], {}
+    i = 0
+    while i < len(argv):
+        tok = argv[i]
+        if tok.startswith("--"):
+            key = tok[2:]
+            if i + 1 < len(argv) and not argv[i + 1].startswith("--"):
+                flags[key] = argv[i + 1]
+                i += 2
+            else:
+                flags[key] = "true"
+                i += 1
+        else:
+            pos.append(tok)
+            i += 1
+    return pos, flags
+
+
+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."""
+    import os
+    p = flags.get("project") or os.environ.get("CLAUDE_PROJECT_DIR")
+    if p:
+        return Path(p).resolve()
+    wd = os.environ.get("WORK_DIR")
+    if wd:
+        return Path(wd).resolve().parent
+    return Path.cwd().resolve()
+
+
+def main() -> int:
+    # Where the payload is, for the one caller that has to import from it rather
+    # than run it: the Stop hook reads config and runs a repo's own extensions, and
+    # doing either from a second implementation would be a second reader of the same
+    # file. It asks the harness where it lives instead of deriving it.
+    if len(sys.argv) > 1 and sys.argv[1] == "--payload":
+        print(Path(__file__).resolve().parent)
+        return 0
+
+    # `--help` prints the same thing no arguments do. The wrapper forwards every
+    # argument untouched — including this one, which it would otherwise be tempted to
+    # answer itself with a summary of a surface it does not own.
+    if len(sys.argv) < 2 or sys.argv[1] in ("--help", "-h", "help"):
+        print(__doc__)
+        return 0 if len(sys.argv) > 1 else 1
+    cmd, rest = sys.argv[1], sys.argv[2:]
+    pos, flags = parse_argv(rest)
+
+    # `config set|unset` runs BEFORE the resolve, and that is not an optimisation.
+    # It is the command you reach for when the config is wrong — and the resolve
+    # below is fatal on a config that is wrong, so ordering it first would make the
+    # one command that can repair an invalid config the one command an invalid
+    # config prevents. `doctor` and `init` are exempt for the same reason, and this
+    # was found the honest way: a half-written `session` block locked the writer out
+    # of all four repos that had it.
+    if cmd == "config" and pos and pos[0] in ("set", "unset"):
+        verb = pos[0]
+        if verb == "set" and len(pos) < 3:
+            die("usage: jarvis work config set <key> <value> [--json]   "
+                "e.g. jarvis work config set ids.prefix ADR")
+        if verb == "unset" and len(pos) < 2:
+            die("usage: jarvis work config unset <key>   "
+                "(back to the shipped default)")
+        return cmd_config({}, {"_verb": verb, "key": pos[1],
+                               "value": pos[2] if len(pos) > 2 else None,
+                               "project_root": _project_root(flags), **flags})
+
+    # Resolve config BEFORE any command runs. `ids` must be reconfigured before
+    # anything compiles a pattern from it, and a command that parsed first would
+    # read the whole repo in the shipped dialect rather than the repo's own.
+    # A broken config is fatal, never a warning: a half-applied config makes every
+    # downstream check report against a model the repo did not choose.
+    try:
+        cfg = resolve(_project_root(flags))
+    except ConfigError as e:
+        # The two commands you reach for WHEN the config is broken cannot be the two
+        # a broken config prevents. The comment above has said they are exempt since
+        # this ordering was written; the code only ever exempted `config set|unset`,
+        # so `doctor`'s own "config is invalid" branch was unreachable and the one
+        # command whose job is diagnosing a broken install died on the install it
+        # was there to diagnose. They run on the shipped defaults and report the
+        # real config themselves.
+        if cmd not in ("doctor", "init"):
+            die(f"{e}")
+        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():
+        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.
+    root = locate_work_root()[0]
+    repo = root.parent if root else _project_root(flags)
+    if cmd in git.WRITES:
+        _say(git.refresh(repo))
+    try:
+        return dispatch(cmd, pos, flags, cfg)
+    finally:
+        # Driven by what CHANGED, never by whether an event was recorded. Not every
+        # command that writes the tree files an event — `version-new` scaffolds a
+        # version.md and records nothing — and a commit that waited for an event
+        # would leave exactly those writes untracked, which is the failure this
+        # 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.
+        item = rows[0]["name"] if rows else (pos[0] if pos else "")
+        committed, pushed, note = git.land(repo, item, rows)
+        if committed:
+            where = f" and pushed to {git.GIT['remote']}" if pushed else ""
+            sys.stdout.flush()
+            print(f"git        committed{where}")
+        _say(note)
+
+
+def _say(note: str) -> None:
+    """A git note the caller has to see. stderr, because it is the difference
+    between a write that is safe and one that is only safe on this machine — and
+    after a flush, so it does not overtake the command's own buffered output and
+    read as though it happened first."""
+    if note:
+        sys.stdout.flush()
+        print(f"git        {note}", file=sys.stderr)
+        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.
+_READS = {"list", "find", "path", "code", "where", "rules", "status", "digest",
+          "log", "needs", "align", "coverage", "readme", "config", "context",
+          "doctor", "kickoff", "remind", "applies", "wrap"}
+
+
+def _reads_only(cmd: str, flags: dict) -> None:
+    """`--branch` reads; it never writes.
+
+    Reading any branch and writing your own is the whole arrangement: a branch's
+    board describes that branch's world and merges when the branch does. Accepting
+    `--branch` on a write would mean committing to a ref this clone does not have
+    checked out — which git can be made to do, and which nobody would then see in
+    their own tree. Refused with the reason, because whoever hit this is one step
+    from what they actually wanted.
+    """
+    if flags.get("branch") and cmd not in _READS:
+        die(f"`{cmd}` changes the board, and a change lands on the branch you have "
+            f"checked out — never on another one. Check out {flags['branch']} and "
+            f"run it there. To LOOK at that branch from here: "
+            f"`jarvis work list --branch {flags['branch']}`, or `jarvis work find`.")
+
+
+def dispatch(cmd, pos, flags, cfg) -> int:
+    _reads_only(cmd, flags)
+    if cmd == "config":
+        # Reads only — `config set|unset` is handled in `main`, ahead of the
+        # resolve, because it has to work in a repo the resolve would refuse.
+        return cmd_config(cfg, flags)
+    if cmd == "method":
+        # The project root for the same reason `context` takes it: instructions resolve
+        # against the repo, and the method has to answer in a repo with a config and no
+        # board yet.
+        return cmd_method(cfg, flags, _project_root(flags))
+    if cmd == "context":
+        # The project root, not the work tree: instructions resolve against the repo
+        # (`.claude/presets/…`), and `context` is the one command that must answer
+        # before a work tree necessarily exists.
+        return cmd_context(cfg, flags, _project_root(flags))
+    if cmd == "remind":
+        # Same reason as `context`: the repo root, and it must answer before a work
+        # tree necessarily exists — a session in a repo that has one config file and
+        # no board still gets told when it is running out of room.
+        return cmd_remind(cfg, flags, _project_root(flags))
+    if cmd == "applies":
+        # The repo root, like `context` and `remind`: this resolves the method against
+        # the repo and the systems against its work tree, and must answer in a repo
+        # that has one and not the other.
+        return cmd_applies(cfg, flags, _project_root(flags))
+    # `init` runs BEFORE a work tree exists, so it takes the project root directly
+    # rather than walking up for a `work/` that is the thing it is about to create.
+    if cmd == "init":
+        return cmd_init({"project_root": _project_root(flags), **flags})
+    # `doctor` must run in a BROKEN repo — that is the whole point — so it takes
+    # the project root and never asks `find_work_root` for a tree that may be the
+    # thing that is wrong.
+    if cmd == "doctor":
+        return cmd_doctor({"project_root": _project_root(flags), **flags})
+    if cmd == "id-new":
+        if not flags.get("host"):
+            die("usage: jarvis work id-new --host <domain|system> --title \"…\"")
+        return cmd_id_new(flags)
+
+    # `new` and `task-new` are one verb. The error message below has advertised `new`
+    # since the ladder was written and nothing dispatched it, so a caller was told the
+    # spelling it had just used was the expected one — this repo's own e2e suite used
+    # it and every test in that story had been dead on the fixture ever since.
+    if cmd in ("task-new", "new"):
+        if not pos:
+            die("usage: jarvis work task-new <name> --epic <e> "
+                "[--priority P0|P1|P2] [--title ...] [--depends a,b] [--tags a,b] "
+                "[--owner <feature>|<domain>] [--code region,region] "
+                "[--covers AC-01,AC-02] [--start YYYY-MM-DD] [--end YYYY-MM-DD]")
+        return cmd_new({"name": pos[0], **flags})
+    if cmd == "epic-new":
+        if not pos:
+            die("usage: jarvis work epic-new <name> [--version <v>] [--title ...] "
+                "[--covers <feature>/AC-01,<feature>/AC-02] "
+                "[--owner <feature>|<domain>] [--continues <epic>]   "
+                "(no --version puts it in the backlog, where cuts are planned)")
+        return cmd_epic_new({"name": pos[0], **flags})
+    if cmd == "feature-new":
+        if not pos:
+            die("usage: jarvis work feature-new <name> "
+                "[--state idea|defined|building|shipped]")
+        return cmd_feature_new({"name": pos[0], **flags})
+    if cmd == "version-new":
+        if not pos:
+            die("usage: jarvis work version-new <name> --outcome \"what a user can "
+                "newly do\" [--title ...] [--order N] [--start YYYY-MM-DD] "
+                "[--end YYYY-MM-DD] [--target YYYY-MM-DD] [--design] "
+                "[--architecture]")
+        return cmd_version_new({"name": pos[0], **flags})
+    if cmd == "place":
+        if not pos:
+            die("usage: jarvis work place <name> --version <v> [--epic <e>]   "
+                "(or --backlog --epic <e> to take it back out of a cut; "
+                "an epic moves whole, a single task needs --epic)")
+        return cmd_place({"name": pos[0], **flags})
+    if cmd == "handoff":
+        if not pos:
+            die("usage: jarvis work handoff <name>")
+        return cmd_handoff({"name": pos[0]})
+    if cmd == "release":
+        if not pos:
+            die("usage: jarvis work release <v>")
+        return cmd_release({"name": pos[0]})
+    if cmd == "archive":
+        if not pos:
+            die("usage: jarvis work archive <v> [--dry-run]")
+        return cmd_archive({"name": pos[0], **flags})
+    if cmd == "find":
+        if not pos:
+            die("usage: jarvis work find <name|branch|#pr>   [--refresh]")
+        return cmd_find({"target": pos[0], **flags})
+    if cmd == "list":
+        return cmd_list(flags)
+    if cmd == "readme":
+        return cmd_readme(flags)
+    if cmd == "move":
+        if len(pos) < 2:
+            die("usage: jarvis work move <name> <queue|in-progress|complete>   "
+                "(to block, use `ask` — a blocked task needs a question)")
+        return cmd_move({"name": pos[0], "status": pos[1], **flags})
+    if cmd == "plan":
+        if not pos:
+            die("usage: jarvis work plan <name> [--file <path>]")
+        return cmd_plan({"name": pos[0], **flags})
+    if cmd == "session":
+        if not pos:
+            die("usage: jarvis work session <name> [--id <uuid>]   "
+                "(no --id records THIS session; --id records one it started)")
+        return cmd_session({"name": pos[0], **flags})
+    if cmd == "kickoff":
+        if not pos:
+            die("usage: jarvis work kickoff <name> [--next \"…\"] [--watch \"…\"] "
+                "[--prompt-only]")
+        return cmd_kickoff({"name": pos[0], **flags})
+    if cmd == "path":
+        if not pos:
+            die("usage: jarvis work path <name>   (a task, an epic or a version)")
+        return cmd_path({"name": pos[0]})
+    if cmd == "code":
+        if not pos:
+            die("usage: jarvis work code <region>")
+        return cmd_code({"region": pos[0]})
+    if cmd == "domain-new":
+        if not pos:
+            die("usage: jarvis work domain-new <name> [--title ...]")
+        return cmd_domain_new({"name": pos[0], **flags})
+    if cmd == "system-new":
+        if not pos:
+            die("usage: jarvis work system-new <name> --code region,region [--title ...]")
+        return cmd_system_new({"name": pos[0], **flags})
+    if cmd == "where":
+        if not pos:
+            die(f"usage: jarvis work where <{ids.LEDGER}-nn>")
+        return cmd_where({"id": pos[0]})
+    if cmd == "rules":
+        return cmd_rules({**flags, "task": flags.get("task") or (pos[0] if pos else None)})
+    if cmd == "align":
+        return cmd_align(flags)
+    if cmd == "wrap":
+        return cmd_wrap(cfg, flags, _project_root(flags))
+    if cmd == "coverage":
+        return cmd_coverage(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
+    # that a run which cannot finish has somewhere to put the reason.
+    if cmd == "next":
+        return cmd_next(flags)
+    if cmd == "status":
+        return cmd_status(flags)
+    if cmd == "drop":
+        if not pos:
+            die("usage: jarvis work drop <name> [--why \"…\"]")
+        return cmd_drop({"name": pos[0], **flags})
+    if cmd == "ask":
+        if not pos:
+            die("usage: jarvis work ask <task> --question \"…\" "
+                "[--options \"a | b\"] [--owner founder] [--durable]")
+        return cmd_ask({"name": pos[0], **flags})
+    if cmd == "answer":
+        if not pos:
+            die("usage: jarvis work answer <task> --choose \"…\" [--to queue]")
+        return cmd_answer({"name": pos[0], **flags})
+    if cmd == "needs":
+        return cmd_needs(flags)
+    if cmd == "verify":
+        return cmd_verify(flags)
+    if cmd == "observed":
+        if not pos:
+            die("usage: jarvis work observed <task> --ac AC-01 --saw \"…\"")
+        return cmd_observed({"name": pos[0], **flags})
+    if cmd == "log":
+        return cmd_log(flags)
+    if cmd == "digest":
+        return cmd_digest(flags)
+    if cmd == "sync":
+        return cmd_sync(flags)
+
+    die(f"unknown subcommand '{cmd}' (expected: {', '.join(SUBCOMMANDS)})")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/package.json

@@ -1,24 +1,18 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.36",
-  "description": "Jarvis — local AI coding assistant CLI",
+  "version": "0.1.39",
+  "description": "Jarvis \u2014 local AI coding assistant CLI",
   "private": false,
   "type": "module",
   "main": "./dist/bin.js",
   "types": "./src/index.ts",
   "bin": {
     "jarvis": "./bin/jarvis.mjs",
-    "jarvis-dev": "./bin/jarvis-dev.mjs",
     "jarvis-pre-tool-use": "./bin/pre-tool-use.mjs",
-    "jarvis-pre-tool-use-dev": "./bin/pre-tool-use.dev.mjs",
     "jarvis-session-start": "./bin/session-start.mjs",
-    "jarvis-session-start-dev": "./bin/session-start.dev.mjs",
     "jarvis-stop": "./bin/stop.mjs",
-    "jarvis-stop-dev": "./bin/stop.dev.mjs",
     "jarvis-user-prompt-submit": "./bin/user-prompt-submit.mjs",
-    "jarvis-user-prompt-submit-dev": "./bin/user-prompt-submit.dev.mjs",
-    "jarvis-config-change": "./bin/config-change.mjs",
-    "jarvis-config-change-dev": "./bin/config-change.dev.mjs"
+    "jarvis-config-change": "./bin/config-change.mjs"
   },
   "exports": {
     ".": "./src/index.ts"
@@ -26,8 +20,19 @@
   "files": [
     "bin/",
     "dist/",
-    "dev/"
+    "harness/",
+    "!harness/**/__pycache__",
+    "!harness/**/*.pyc"
   ],
+  "scripts": {
+    "dev": "tsx watch src/bin.ts start --foreground",
+    "build": "tsup",
+    "build:tsc": "tsc",
+    "start": "node dist/bin.js start",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm build",
+    "test:run": "vitest run"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -35,43 +40,32 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.101",
-    "@anthropic-ai/sdk": "^0.39.0",
-    "chalk": "^5.4.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "chokidar": "^4.0.0",
-    "cli-highlight": "^2.1.0",
     "commander": "^13.0.0",
     "dotenv": "^16.4.0",
-    "ink": "^5.2.0",
-    "ink-select-input": "^6.0.0",
-    "ink-spinner": "^5.0.0",
-    "ink-text-input": "^6.0.0",
-    "marked": "^15.0.0",
-    "react": "^18.3.0",
+    "fast-glob": "^3.3.2",
+    "jiti": "^2.4.2",
+    "node-pty": "^1.1.0",
+    "picomatch": "^4.0.2",
     "tsx": "^4.0.0",
-    "ws": "^8.18.0"
+    "ws": "^8.18.0",
+    "yaml": "^2.6.0",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
-    "@types/react": "^18.3.0",
+    "@jarvis/agents": "workspace:*",
+    "@jarvis/anthropic": "workspace:*",
+    "@jarvis/board": "workspace:*",
+    "@jarvis/data": "workspace:*",
+    "@jarvis/logger": "workspace:*",
+    "@jarvis/rpc": "workspace:*",
+    "@jarvis/types": "workspace:*",
+    "@jarvis/typescript-config": "workspace:*",
+    "@jarvis/vitest-config": "workspace:*",
     "@types/ws": "^8.5.0",
     "tsup": "^8.5.1",
     "typescript": "^5.7.0",
-    "@jarvis/agent": "0.0.0",
-    "@jarvis/agents": "1.0.0",
-    "@jarvis/anthropic": "1.0.0",
-    "@jarvis/logger": "1.0.0",
-    "@jarvis/sdk": "1.0.0",
-    "@jarvis/tasks": "1.0.0",
-    "@jarvis/types": "1.0.0",
-    "@jarvis/transport": "1.0.0",
-    "@jarvis/typescript-config": "1.0.0",
-    "@jarvis/mcp": "0.1.0"
-  },
-  "scripts": {
-    "dev": "tsx watch src/bin.ts -- start",
-    "build": "tsup",
-    "build:tsc": "tsc",
-    "start": "node dist/bin.js start",
-    "type-check": "tsc --noEmit"
+    "vitest": "^2.1.0"
   }
-}
+}

package/bin/config-change.dev.mjs

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Jarvis ConfigChange hook — Dev Launcher.
- * See bin/pre-tool-use.dev.mjs for the pattern.
- */
-
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-import { existsSync } from "fs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const bundle = join(__dirname, "..", "dev", "hooks", "config-change.js");
-
-if (!existsSync(bundle)) process.exit(0);
-
-await import(bundle);