@appchy/jarvis 0.1.112 → 0.1.114

package/dist/bin.js

@@ -10284,7 +10284,7 @@ import { createRequire as createRequire2 } from "module";
 var _require = createRequire2(import.meta.url);
 var VERSION2 = _require("../package.json").version ?? "0.0.0";
 var IS_DEV = String(_require("../package.json").name ?? "").endsWith("-dev");
-var SHA = "dd146f8";
+var SHA = "3c9f85d";
 var BUILT = "2026-09-12";
 var BUILD = SHA ?? "source";
 var BUILD_LABEL = `${SHA ? `${VERSION2} (${SHA}${BUILT ? ` ${BUILT}` : ""})` : `${VERSION2} (source)`}${IS_DEV ? " \u2014 development build" : ""}`;

package/harness/harness/align.py

@@ -400,14 +400,17 @@ def _align_versions(root: Path, s: dict) -> list:
                     out.append(("warn", "released-brief", f"version {v.name}: "
                                 f"released but still carries {brief} — a cut-local "
                                 f"brief collapses at release"))
-            # Same rule, one tier down: an epic is the plan-it-together doc, and
-            # `release` removes it. One left standing means a release that did not
-            # go through `jarvis work release`.
+            # One tier down the test inverts: a released plan is KEPT, so its
+            # presence is correct and what would be wrong is an unstamped one. An
+            # epic plan with no released banner means a release that did not go
+            # through `jarvis work release` — or a plan added to a cut afterwards,
+            # which is the same problem wearing different clothes.
+            from .epic import _RELEASED_MARKER
             for e in v.epics:
-                if e.planned:
+                if e.planned and _RELEASED_MARKER not in e.md.read_text(errors="ignore"):
                     out.append(("warn", "released-brief", f"version {v.name}: "
-                                f"released but epic '{e.name}' still carries "
-                                f"epic.md — an epic archives at release"))
+                                f"released but epic '{e.name}' carries a plan that is "
+                                f"not stamped as released — it reads as live direction"))
     return out
 #: An agent-file reference in skill prose, in either of the two shapes an agent dir
 #: takes: `.claude/agents/<name>.md` in a repo that keeps its own agents, and a bare

package/harness/harness/epic.py

@@ -220,13 +220,19 @@ _DURABLE_SECTIONS = ("## Governance this implies", "## Non-goals", "### Settled"
                      "### Forward-compat")
 
 
-def removal_cost(version) -> tuple:
-    """What releasing this cut would delete: `(plans, bytes, sections)`.
+def plans_held(version) -> tuple:
+    """What this cut's epic plans hold: `(plans, bytes, sections)`.
 
-    One derivation, because two surfaces quote this price now — the notice
-    `release` prints just before the unlink, and the line `status` shows a person
-    deciding whether to run it at all. A warning and a confirmation that disagreed
-    about the cost would make both worth less than either.
+    One derivation, because two surfaces quote it — the notice `release` prints as
+    it stamps the plans, and the line `status` shows a person deciding whether to
+    run it at all. Two surfaces that disagreed about what a cut carries would make
+    both worth less than either.
+
+    It measured what release was about to DELETE until 2026-09-12, when a released
+    plan started being kept instead. The number is the same number; what it is
+    evidence for is not. It now says how much settled prose is going quiet, which is
+    the argument for lifting the durable half into an owner file — not a last call
+    before the bytes go.
 
     `sections` is every durable heading found across the plans, deduplicated: it is
     what a reader needs to judge whether the text is safe to lose, and it is the
@@ -245,21 +251,23 @@ def removal_cost(version) -> tuple:
     return len(plans), total, sorted(held)
 
 
-def _cost_of_removing(version, root) -> list:
-    """What this release is about to delete, as lines a person can act on.
+def _cost_of_closing(version, root) -> list:
+    """What this release is about to stamp shut, as lines a person can act on.
+
+    **Said while the plans are still the live thing a reader would reach for.** The
+    text no longer leaves the tree — a released plan is stamped and kept — so this is
+    not a last call before the bytes go. It is the argument for the sweep: a stamped
+    plan is history, and a decision left in one is a decision the next session will
+    not find when it reads the owner file.
 
-    **Said BEFORE the unlink, because the advice that follows a release is useless
-    after it.** `release` has always printed _"promote still-load-bearing decisions
-    to the domain that owns them"_ — and printed it after the files holding those
-    decisions had already left the tree. Measured 2026-09-11 on `01-one-board`: twelve
-    plans, 450,405 bytes, about a hundred durable statements with no owner file, and
-    the recovery commit had to be worked out by hand afterwards from `git log
-    --diff-filter=D`.
+    Measured 2026-09-11 on `01-one-board`: twelve plans, 450,405 bytes, about a
+    hundred durable statements with no owner file. Those plans were deleted by the
+    release that day and restored on 2026-09-12, which is why deletion is no longer
+    what this reports.
 
-    So this names the size, the sections that can outlive the plan, and the commit
-    where the text still lives. It does not judge whether a statement is durable —
-    that is the judgement a lint cannot make, and claiming it would be worse than
-    saying nothing.
+    It names the size and the sections that can outlive the plan. It does not judge
+    whether a statement is durable — that is the judgement a lint cannot make, and
+    claiming it would be worse than saying nothing.
     """
     plans = [e for e in version.epics if e.planned]
     if not plans:
@@ -275,57 +283,77 @@ def _cost_of_removing(version, root) -> list:
                 for h in _DURABLE_SECTIONS if h in text]
         note = f" — holds §{', §'.join(held)}" if held else ""
         out.append(f"          {e.name}  {len(text.encode()):,} bytes{note}")
-    head = _still_holds(root)
-    return ([f"\n        DELETING {len(plans)} epic plan(s), {total:,} bytes. Anything "
-             f"durable in them must already be in the file that owns it — after this "
-             f"they are in git only, and nobody reads git for a decision:"]
+    return ([f"\n        STAMPING {len(plans)} epic plan(s), {total:,} bytes, as released. "
+             f"They stay in the tree and every link to them keeps resolving — but a "
+             f"stamped plan is history, so anything durable belongs in the file that "
+             f"owns it:"]
             + out
-            + ([f"          the text stays recoverable at {head}"] if head else [])
-            + ["          `git show <commit>:<path>` — and `jarvis work align` reports "
-               "what cites a file that is gone"])
+            + ["          `jarvis work align` reports what cites a file that is gone"])
+
 
+#: What a released plan opens with. Matched on the marker rather than the whole line,
+#: so a cut reopened and released again finds its own stamp instead of stacking a second.
+_RELEASED_MARKER = "> **A released plan"
 
-def _still_holds(root) -> str:
-    """The commit whose tree still contains these plans, or empty when git cannot say.
 
-    HEAD is the right answer, and it is worth being precise about why: the unlink has
-    not happened yet and the board write commits after it, so at the moment this
-    prints, the newest commit in the history is one that still holds every file about
-    to go. Through the same seam every other git question goes through — a second way
-    of asking would eventually give a second answer.
+def _stamp_released(epic, version_name) -> bool:
+    """Mark a plan as history in the file itself. True when it was added.
+
+    In the document rather than in the folder name, because a reader who followed a
+    link is holding the document and never saw the folder. After the frontmatter and
+    before the first heading, which is the one place it cannot be scrolled past.
     """
-    from . import git
-    code, out, _ = git._git(root.parent, "rev-parse", "--short", "HEAD")
-    return out.strip() if code == 0 else ""
+    text = epic.md.read_text()
+    if _RELEASED_MARKER in text:
+        return False
+    banner = (f"{_RELEASED_MARKER} — `{version_name}` shipped "
+              f"{date.today().isoformat()}.**\n"
+              f"> It says how the work was planned, never what is true now. Anything here\n"
+              f"> that still governs belongs in the file that owns it — `jarvis work where "
+              f"<id>` finds one.\n\n")
+    if text.startswith("---\n"):
+        close = text.index("\n---\n", 3) + len("\n---\n")
+        text = text[:close] + "\n" + banner + text[close:].lstrip("\n")
+    else:
+        text = banner + text
+    epic.md.write_text(text)
+    return True
 
 
 def cmd_epic_release(root, version) -> int:
-    """Remove every `epic.md` in a released version, and report it.
+    """Stamp every `epic.md` in a released version as history, and KEEP it.
 
-    An epic is TEMPORARY by definition: it is the plan-it-together doc, and how
-    the work was planned stops being true the moment it ships. The folder stays
-    as the grouping of what shipped — that record is worth keeping — and git
-    holds the plan. Called from `cmd_release`, never on its own.
+    An epic is temporary: how the work was planned stops being true the moment it
+    ships. What does not follow is that the file should go. Deleting it was the rule
+    until 2026-09-12, and the price was measured rather than argued: releasing
+    `01-one-board` removed twelve plans, left 104 links across the repo pointing at a
+    file that no longer existed, and put the text somewhere only a person who knew the
+    commit could reach. Nobody reads git for a decision.
 
-    It says what it is deleting FIRST. The cost of a release is not the stamp, it is
-    the plans that go with it, and a person deciding needs that in front of them
-    while the files still exist."""
-    for line in _cost_of_removing(version, root):
+    So the plan stays where every link already points and travels to the archive with
+    the rest of the cut, which `links.repairing` handles like any other move. The
+    sweep that lifts durable statements into their owner files is still worth doing —
+    it is just no longer a race against an unlink.
+
+    Called from `cmd_release`, never on its own.
+    """
+    for line in _cost_of_closing(version, root):
         print(line)
-    removed = []
+    stamped = []
     for e in version.epics:
-        # An epic with no plan doc is already in the shape this produces — a folder
-        # grouping tasks. Unlinking regardless raised AFTER `released:` had been
-        # stamped, so the cut read as released while every other epic kept the file
-        # this exists to remove.
+        # An epic with no plan doc has nothing to stamp. It was also the case that
+        # unlinking regardless raised AFTER `released:` was stamped, leaving the cut
+        # reading as released with every other plan untouched.
         if not e.planned:
             continue
-        e.md.unlink()
-        removed.append(e.name)
-    if removed:
-        print(f"        archived {len(removed)} epic(s) — epic.md removed, "
-              f"folders kept as the grouping: {', '.join(removed)}")
-    return len(removed)
+        if _stamp_released(e, version.name):
+            stamped.append(e.name)
+    if stamped:
+        print(f"        stamped {len(stamped)} epic plan(s) as released and kept them "
+              f"in place: {', '.join(stamped)}")
+    return len(stamped)
+
+
 def epic_for_task(root, args, version_name):
     """Resolve the `--epic` a task command names, and check it agrees with any
     `--version` also given. Returns (epic, version_name) — the version is

package/harness/harness/shift.py

@@ -27,7 +27,7 @@ from .tree import BLOCKED, BUCKETS, die, find_work_root, rel
 from .frontmatter import rewrite_file
 from .model import locate, missing, record_session, scan
 from .generate import _sync
-from .epic import removal_cost
+from .epic import plans_held
 from . import autonomy, events, links, peers
 # The ceiling is read through the MODULE, never bound in with `from … import`.
 # A `from .autonomy import CEILING` captures the value at import time, so
@@ -286,10 +286,11 @@ def cmd_status(args) -> int:
     ready = [v for v in s["versions"] if v.finishable()]
     print(f"WAITING ON YOU  ({len(waiting) + len(ready)})")
     for v in ready:
-        plans, size, held = removal_cost(v)
+        plans, size, held = plans_held(v)
         cost = ""
         if plans:
-            cost = (f" — releasing deletes {plans} epic plan(s), {size:,} bytes"
+            cost = (f" — releasing stamps {plans} epic plan(s) as history, "
+                    f"{size:,} bytes"
                     + (f", holding §{', §'.join(held)}" if held else ""))
         print(f"  {v.name}: every task is complete and the cut is still open "
               f"— `jarvis work release {v.name}`{cost}")

package/harness/harness/version.py

@@ -198,12 +198,12 @@ def cmd_release(args) -> int:
     # how the work was planned stops being true once it ships.
     cmd_epic_release(root, version)
     print("\nDistill before archiving:")
-    # Points at the commit the deletion just named, because this instruction used to
-    # send a reader to files the same command had already removed — and the one time
-    # it mattered, the recovery commit had to be reconstructed afterwards with
-    # `git log --diff-filter=D`.
+    # The plans are still in the tree, stamped as history, so this points at them
+    # rather than at a commit. It sent a reader to files the same command had already
+    # removed until 2026-09-12, and the one time it mattered the recovery commit had
+    # to be reconstructed afterwards with `git log --diff-filter=D`.
     print("  1. Promote still-load-bearing decisions to the domain or system that owns "
-          "them — read them from the commit named above; they are no longer in the tree")
+          "them — the plans are stamped and kept, so read them where they sit")
     print(f"  2. Repoint any inbound deep-links to those {ids.LEDGER}-nn entries")
     print(f"  3. {cli()} archive {name}   (strips each task to task.md, and "
           f"files a RELEASED cut under versions/complete/)")

package/harness/presets/appchy/PRESET.md

@@ -308,9 +308,9 @@ files are deleted. **Read a dissolving `epic.md` in full first** — a thin epic
 fully-planned, deliberately-deferred goal hides.
 
 A version's status is derived: **planned** until tasks start, **current** while any is in-progress,
-**released** once `jarvis work release` stamps it. Release **flattens the done tier**, removes each
-`epic.md`, then `work archive` strips each task to its `task.md` and moves the version to
-`work/archive/versions/<v>/`.
+**released** once `jarvis work release` stamps it. Release **flattens the done tier** and **stamps
+each `epic.md` as history, keeping it**, then `jarvis work archive` strips each task to its `task.md`
+and moves the version to `work/archive/versions/<v>/`.
 
 **Archived is off the board, not gone.** `list`, the README table and every lint see only `versions/`.
 `jarvis work path <v>` and `jarvis work where <id>` still resolve into the archive.
@@ -338,8 +338,9 @@ is a brief and nothing else.
 says so, and it is right: that is an epic wearing a task costume. Split it by *goal*, not by layer.
 
 `epic.md` is mandatory for an epic and owns three things nothing else does — the **Goal** in user
-terms, the **Plan** every task builds against, and **Governance this implies**. It is **removed by
-`jarvis work release`**.
+terms, the **Plan** every task builds against, and **Governance this implies**. `jarvis work
+release` **stamps it as history and keeps it** — it used to delete it, which cost 104 dangling links
+and put the text where only somebody who knew the commit could read it (2026-09-12).
 
 `handoff.md` is the **cross-conversation** artifact, not a per-task journal: **not** scaffolded on
 pickup — create it with `jarvis work handoff <name>` only when handing the task to a fresh session. A task
@@ -459,8 +460,8 @@ The two task-count rules are one rule from both ends: **a task is one goal, an e
 **done** epic is exempt from the floor; it is history, not a plan.
 
 `jarvis work align` reports every misalignment class — dangling citation · orphan/uncovered AC · unenforced
-rule · retired concept still named live · complete-but-unreleased version · an `epic.md` surviving a
-release. Report-only, exit 0.
+rule · retired concept still named live · complete-but-unreleased version · a released cut whose
+`epic.md` is not stamped as history. Report-only, exit 0.
 
 ## Every board write lands in git
 
@@ -716,8 +717,10 @@ The spend is authored prose. Keep it tight:
 - **Cannot `new` or `epic-new` into a released version.**
 - **Cannot `release`** a version with incomplete tasks, zero tasks, or no `outcome:`. **Cannot
   `archive`** one that isn't released.
-- **`release` deletes every `epic.md`.** Anything durable in an epic's §Plan or §Governance must have
-  landed in its owner doc before you release — git keeps the text, but nobody will look.
+- **`release` stamps every `epic.md` as history and keeps it** (2026-09-12; it deleted them until
+  then). Nothing is lost and every link still resolves — but a stamped plan is history, so anything
+  durable in its §Plan or §Governance still belongs in the file that owns it. A reader who needs a
+  decision reads the owner file, and will not go looking in a shipped cut's plan.
 - **Names are globally unique across tasks, epics and versions.** Renaming = move the folder by hand +
   update any `depends_on:`.
 - **`README.md` BACKLOG markers are load-bearing** — preserve them if you hand-edit around the table.

package/harness/test_work.py

@@ -506,21 +506,43 @@ def test_a_grandfathered_flat_version_still_reads():
         assert [t.epic for t in ver.all_tasks()] == [None]
 
 
-def test_release_removes_epic_md_without_orphaning_its_tasks():
-    # The bug this guards: `release` deletes the plan doc, so "an epic is a dir
-    # with epic.md" would stop matching and the shipped tasks would disappear.
+def test_release_stamps_the_plan_as_history_and_keeps_it():
+    # Release deleted the plan until 2026-09-12. It cost 104 dangling links across
+    # the repo and put the text where only somebody who knew the commit could read
+    # it, so the plan is now stamped and kept. What this guards is that the stamp
+    # actually lands in the file a reader opens — a folder-level marker would be
+    # invisible to anyone who arrived by following a link.
     with tempfile.TemporaryDirectory() as tmp:
         v = _tree(tmp)
         e = _epic(v, "publish-under-your-name")
         _task(e / "complete", "author-a-lesson")
         version.cmd_epic_release(Path(tmp), model.Version(v))
-        assert not (e / "epic.md").exists()
+        assert (e / "epic.md").is_file()
+        body = (e / "epic.md").read_text()
+        assert epic._RELEASED_MARKER in body
+        # Before the first heading, so it cannot be scrolled past.
+        assert body.index(epic._RELEASED_MARKER) < body.index("# ")
         after = model.Version(v)
         assert [x.name for x in after.epics] == ["publish-under-your-name"]
-        assert after.epics[0].planned is False
+        assert after.epics[0].planned is True
         assert [t.name for t in after.all_tasks()] == ["author-a-lesson"]
 
 
+def test_releasing_twice_does_not_stack_a_second_stamp():
+    # A cut can be reopened and released again, and `align` reads the marker to tell
+    # a stamped plan from a live one. Two banners would still read as stamped, so
+    # this is about the document staying readable rather than about the check.
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "publish-under-your-name")
+        _task(e / "complete", "author-a-lesson")
+        version.cmd_epic_release(Path(tmp), model.Version(v))
+        first = (e / "epic.md").read_text()
+        version.cmd_epic_release(Path(tmp), model.Version(v))
+        assert (e / "epic.md").read_text() == first
+        assert first.count(epic._RELEASED_MARKER) == 1
+
+
 def test_a_finished_epic_drops_into_the_done_tier_and_comes_back_out():
     # The tier is DERIVED, so the only thing that may move an epic is what its
     # tasks say — and it has to work in BOTH directions, or reopening a task would
@@ -951,13 +973,13 @@ def test_a_flat_version_is_grandfathered_but_a_mixed_one_is_not():
         assert any("straggler: loose in version" in w for w in _warns(Path(tmp)))
 
 
-def test_release_removes_epic_md_for_an_epic_parked_in_the_done_tier():
+def test_release_stamps_the_plan_of_an_epic_parked_in_the_done_tier():
     # THE bug on release's only normal path. A version is releasable only when every
     # task is complete — which is exactly the condition that parks each epic in
     # `<v>/complete/`. `release` flattens that tier first, then removed `epic.md`
     # from the PRE-MOVE model: FileNotFoundError, raised *after* `released:` was
-    # already stamped. A traceback, a half-applied release, and `epic.md` — the one
-    # file release exists to remove — left behind for `align` to report.
+    # already stamped. A traceback, a half-applied release, and an unstamped plan
+    # left behind for `align` to report.
     import os
     with tempfile.TemporaryDirectory() as tmp:
         root = Path(tmp)
@@ -970,10 +992,13 @@ def test_release_removes_epic_md_for_an_epic_parked_in_the_done_tier():
         finally:
             os.environ.pop("WORK_DIR")
 
-        # Flattened out of the done tier, epic.md gone, folder kept as the grouping.
+        # Flattened out of the done tier, the plan kept and stamped, folder kept as
+        # the grouping.
         assert (v / "a-shipped-goal").is_dir()
         assert not (v / tree.DONE_TIER).exists()
-        assert not list(v.rglob("epic.md")), "release must remove every epic.md"
+        plans = list(v.rglob("epic.md"))
+        assert len(plans) == 1, "release must keep the plan, not remove it"
+        assert epic._RELEASED_MARKER in plans[0].read_text()
         assert (v / "a-shipped-goal" / "complete" / "shipped-thing" / "task.md").is_file()
         assert model.Version(v).released
 
@@ -6394,7 +6419,8 @@ def test_an_epic_whose_plan_doc_is_gone_still_moves_into_a_cut():
 def test_releasing_a_cut_holding_an_epic_with_no_plan_doc_still_releases_it():
     # The unlink ran on every epic, so one without a plan doc raised — and it raised
     # AFTER `released:` was stamped, leaving the cut reading as released while every
-    # other epic kept the file release exists to remove.
+    # other epic went untouched. The stamp has the same shape of hazard: an epic with
+    # nothing to stamp must be skipped rather than read.
     with tempfile.TemporaryDirectory() as tmp:
         root = Path(tmp)
         v = _tree(tmp)
@@ -6412,9 +6438,10 @@ def test_releasing_a_cut_holding_an_epic_with_no_plan_doc_still_releases_it():
 
         after = model.locate_version(root, "26-cut")
         assert after.released, "the cut never got its released stamp"
-        assert not (after.folder / "publish-under-your-name" / "epic.md").exists() \
-            and not (after.folder / "complete" / "publish-under-your-name" / "epic.md").exists(), \
-            "a plan doc survived the release"
+        plans = list(after.folder.rglob("epic.md"))
+        assert len(plans) == 1, "the epic that had a plan should still have exactly one"
+        assert plans[0].parent.name == "publish-under-your-name"
+        assert epic._RELEASED_MARKER in plans[0].read_text(), "the kept plan is unstamped"
 
 
 def test_a_shipped_criterion_delivered_by_a_filed_cut_is_still_covered():
@@ -7403,13 +7430,13 @@ def test_the_stop_hook_being_switched_off_silences_the_standing_too():
 
 
 
-def test_a_release_says_what_it_is_deleting_before_it_deletes_it():
-    # `release` has always printed "promote still-load-bearing decisions to the
-    # domain that owns them" — AFTER unlinking the files holding those decisions.
-    # Measured on 01-one-board: twelve plans, 450,405 bytes, about a hundred durable
-    # statements with no owner file, and the recovery commit reconstructed afterwards
-    # by hand with `git log --diff-filter=D`. The cost of a release is the plans that
-    # go with it, so it is named while they still exist.
+def test_a_release_says_what_it_is_stamping_shut():
+    # `release` has always printed "promote still-load-bearing decisions to the domain
+    # that owns them", and until 2026-09-12 it printed that AFTER unlinking the files
+    # holding those decisions. Measured on 01-one-board: twelve plans, 450,405 bytes,
+    # about a hundred durable statements with no owner file. The plans are now kept
+    # and stamped rather than deleted, so what the notice owes a reader changed with
+    # it: not a last call before the bytes go, but the argument for the sweep.
     with tempfile.TemporaryDirectory() as tmp:
         try:
             repo = _git_repo(tmp, push=False)
@@ -7432,22 +7459,22 @@ def test_a_release_says_what_it_is_deleting_before_it_deletes_it():
             with _work_dir(str(repo / "work")):
                 said = _capture_stdout(lambda: version.cmd_release({"name": "09-a-cut"}))
 
-            # The cost, in front of the person, in units they can weigh.
-            assert "DELETING 1 epic plan(s)" in said, said
+            # What is going quiet, in front of the person, in units they can weigh.
+            assert "STAMPING 1 epic plan(s)" in said, said
             assert "bytes" in said
             # WHICH sections can outlive the plan — and not the ones that cannot.
             assert "§Governance this implies" in said, said
             assert "§Plan" not in said, "slice ordering is supposed to die with the epic"
-            # Where it went, named at the moment it goes rather than reconstructed later.
-            assert head and head in said, f"expected the recovery commit {head}: {said}"
 
-            # And the claim is true: the plan is out of the tree and in that commit.
-            assert not (v / "an-epic" / "epic.md").exists()
-            kept = _git(repo, "show", f"{head}:work/versions/09-a-cut/an-epic/epic.md")
-            assert "a rule is owed" in kept.stdout, kept.stderr
+            # And the claim is true: the plan is still there, and stamped.
+            plan = v / "an-epic" / "epic.md"
+            assert plan.is_file(), "a released plan is kept, not deleted"
+            assert "a rule is owed" in plan.read_text()
+            assert epic._RELEASED_MARKER in plan.read_text()
 
-            # The instruction that follows no longer sends a reader to a deleted file.
-            assert "no longer in the tree" in said, said
+            # Nothing sends a reader to git for the text any more, because it is here.
+            assert "no longer in the tree" not in said, said
+            assert head not in said or "recoverable" not in said, said
         finally:
             events._PENDING.clear()
             config.apply(config.DEFAULTS)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.112",
+  "version": "0.1.114",
   "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/anthropic": "1.0.0",
     "@jarvis/board": "0.1.0",
-    "@jarvis/errors": "1.0.0",
     "@jarvis/data": "0.1.0",
+    "@jarvis/errors": "1.0.0",
     "@jarvis/logger": "1.0.0",
-    "@jarvis/types": "1.0.0",
     "@jarvis/rpc": "1.0.0",
+    "@jarvis/anthropic": "1.0.0",
+    "@jarvis/types": "1.0.0",
     "@jarvis/typescript-config": "1.0.0",
-    "@jarvis/ui": "0.1.0",
-    "@jarvis/vitest-config": "1.0.0"
+    "@jarvis/vitest-config": "1.0.0",
+    "@jarvis/ui": "0.1.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",