loopmath 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
loopmath/__init__.py CHANGED
@@ -5,4 +5,4 @@ The command line (`loopmath`, or its alias `loop`) is the interface; see the
5
5
  README and `loopmath --help`.
6
6
  """
7
7
 
8
- __version__ = "0.3.2"
8
+ __version__ = "0.3.4"
loopmath/cli.py CHANGED
@@ -14,7 +14,7 @@ Verbs:
14
14
  plan: task-types workflows recommend builder plan
15
15
  record: run start|record|import|attempt|artifact|finish|sessions outcome budget config
16
16
  learn: fit onboard share
17
- view: runs posterior status report doctor skill ocp
17
+ view: runs posterior status report doctor guide skill ocp
18
18
 
19
19
  No verb in this CLI connects to another machine; builder serves on 127.0.0.1 only.
20
20
  Verbs write only to the store ($LOOPMATH_HOME, default ~/.loopmath, which also
loopmath/cli_registry.py CHANGED
@@ -633,9 +633,16 @@ def _add_viewing(sub) -> None:
633
633
  _common(p)
634
634
  p.set_defaults(func=_lazy("loopmath.skill.commands:doctor"))
635
635
 
636
- p = sub.add_parser("skill", help="install, remove or print the orchestrator skills")
636
+ p = sub.add_parser("guide", help="print the instructions for one job (onboard, import, plan, record, fit) or "
637
+ "the command reference, for an agent to follow; read only")
638
+ p.add_argument("topic", nargs="?", default=None, metavar="TOPIC",
639
+ help="onboard, import, plan, record, fit or reference (default: list them, with when to use each)")
640
+ p.set_defaults(func=_lazy("loopmath.skill.guide:command"))
641
+
642
+ p = sub.add_parser("skill", help="install, remove or print the loopmath skill")
637
643
  ss = p.add_subparsers(dest="skill_command", required=True)
638
- for verb, helptext in (("install", "write the six skills for Claude Code, Codex or both"),
644
+ for verb, helptext in (("install", "write the loopmath skill for Claude Code, Codex or both, and remove the job "
645
+ "skills 0.3.3 and older installed"),
639
646
  ("uninstall", "remove what install wrote")):
640
647
  q = ss.add_parser(verb, help=helptext)
641
648
  q.add_argument("--target", default="auto", choices=["auto", "claude-code", "codex", "both"],
@@ -645,14 +652,12 @@ def _add_viewing(sub) -> None:
645
652
  q.add_argument("--dir", default=None, metavar="PATH", help="the project folder for --scope project "
646
653
  "(default: this folder)")
647
654
  if verb == "install":
648
- q.add_argument("--dry-run", action="store_true", help="print every file install would write or "
649
- "change, and write nothing")
655
+ q.add_argument("--dry-run", action="store_true", help="print every file install would write, change "
656
+ "or remove, and write nothing")
650
657
  _common(q)
651
658
  q.set_defaults(func=_lazy(f"loopmath.skill.commands:{verb}"))
652
- q = ss.add_parser("show", help="print one skill (default loopmath, the start-here skill) or the shared reference")
653
- q.add_argument("name", nargs="?", default="loopmath", metavar="NAME",
654
- help="loopmath, loopmath-onboard, loopmath-import-runs, loopmath-update-fit, loopmath-plan-task, "
655
- "loopmath-record-run, or reference")
659
+ q = ss.add_parser("show", help="print the loopmath skill (the job guides are `loopmath guide`)")
660
+ q.add_argument("name", nargs="?", default="loopmath", metavar="NAME", help="loopmath, the one skill")
656
661
  q.set_defaults(func=_lazy("loopmath.skill.commands:show"))
657
662
 
658
663
  p = sub.add_parser("ocp", help="validate or migrate OCP documents")
@@ -127,7 +127,7 @@ def onboard(args: argparse.Namespace) -> int:
127
127
  print(f"onboard: reading Claude Code and Codex history, {_window_words(since)}"
128
128
  + ("" if H.parse_cache().is_file() else "; a large history can take several minutes on the first read"),
129
129
  file=sys.stderr, flush=True)
130
- # Then, also when captured, what the answers start from, once (the skill shows this line to the user).
130
+ # Then, also when captured, what the answers start from, once (the onboard guide shows this line to the user).
131
131
  prior = starting_prior()
132
132
  print(prior["line"], file=sys.stderr, flush=True)
133
133
  hist = deps.load_history(since_days, logs=deps.logs, progress=_progress, stage=_stage)
@@ -1,4 +1,5 @@
1
1
  """Handlers for `loopmath doctor` and `loopmath skill install|uninstall|show`.
2
+ (`loopmath guide` is guide.py's, which imports nothing else.)
2
3
  """
3
4
 
4
5
  from __future__ import annotations
@@ -36,16 +37,9 @@ _WOULD = {"created": "to write", "updated": "to update", "replaced": "to replace
36
37
  "removed": "to remove", "unchanged": "unchanged", "kept": "kept"}
37
38
 
38
39
 
39
- def _count(entries: list[dict], dry_run: bool = False) -> str:
40
- counts: dict[str, int] = {}
41
- for e in entries:
42
- counts[e["action"]] = counts.get(e["action"], 0) + 1
43
- return ", ".join(f"{n} {_WOULD[action] if dry_run else action}" for action, n in counts.items())
44
-
45
-
46
40
  def _results(verb: str, results: list[dict], as_json: bool) -> None:
47
41
  if as_json:
48
- emit_json("loopmath.skill/2", {"verb": verb, "results": results})
42
+ emit_json("loopmath.skill/3", {"verb": verb, "results": results})
49
43
  return
50
44
  dry = any(r.get("dry_run") for r in results)
51
45
  if dry:
@@ -53,19 +47,20 @@ def _results(verb: str, results: list[dict], as_json: bool) -> None:
53
47
  for r in results:
54
48
  form = " (AGENTS.md block)" if r["method"] == "agents_block" else ""
55
49
  head = f"{r['target']} {r['scope']}{form}"
56
- actions = {e["action"] for e in r["skills"] + r["reference"]}
57
- if verb == "uninstall" and actions <= {"absent"}:
50
+ [skill] = r["skills"]
51
+ if verb == "uninstall" and skill["action"] == "absent" and not r["removed"]:
58
52
  print(f"{head}: not installed in {r['root']}, nothing to remove")
59
- elif verb == "uninstall" and actions <= {"removed", "absent"}:
60
- n = sum(e["action"] == "removed" for e in r["skills"])
61
- print(f"{head}: removed {n} skill{'s' if n != 1 else ''} and the reference.md beside each from {r['root']}")
62
- else:
63
- print(f"{head}: {len(r['skills'])} skills in {r['root']}: {_count(r['skills'], dry)}")
64
- if dry:
65
- print(f" and in each skill folder a copy of the shared reference.md ({_count(r['reference'], dry)}), "
66
- f"and {r['manifest']}, the list of the files install wrote")
53
+ continue
54
+ print(f"{head}:")
55
+ if skill["action"] != "absent":
56
+ print(f" {_WOULD[skill['action']] if dry else skill['action']} {skill['path']}, the loopmath skill")
57
+ action = r.get("manifest_action")
58
+ if dry and action:
59
+ print(f" {_WOULD[action]} {r['manifest']}, the list of the files install wrote")
67
60
  for e in r["removed"]:
68
61
  print(f" {'to remove' if dry else 'removed'} {e['path']}")
62
+ if any(e["path"].endswith(f"/{name}/SKILL.md") for e in r["removed"] for name in _install.RETIRED_SKILLS):
63
+ print(" (0.3.4 installs one skill; the job skills' text comes from `loopmath guide` now)")
69
64
  block, where = r.get("block"), r.get("block_file") or r.get("agents_md")
70
65
  if block == "removed":
71
66
  print(f" {'to remove' if dry else 'removed'} the loopmath block from {where}")
@@ -104,5 +99,8 @@ def show(args: argparse.Namespace) -> int:
104
99
  try:
105
100
  sys.stdout.write(_install.skill_text(name))
106
101
  except KeyError:
107
- return fail(f"no skill {name!r}; one of {', '.join(_install.SKILLS)}, or reference")
102
+ topic = "reference" if name == "reference" else _install.RETIRED_SKILLS.get(name)
103
+ if topic:
104
+ return fail(f"0.3.4 has one skill, loopmath; {name} is `loopmath guide {topic}` now")
105
+ return fail(f"no skill {name!r}; the one skill is loopmath, and `loopmath guide` lists the job guides")
108
106
  return EXIT_OK
loopmath/skill/doctor.py CHANGED
@@ -6,7 +6,8 @@ Six checks, each `ok`, `warn` or `fail`:
6
6
  store the store root exists and is writable
7
7
  fit `fits/latest` present, and its age
8
8
  prices every model seen in the scan window has a price
9
- skill where the skill set is installed (and which Codex form), and whether it is whole and current
9
+ skill where the loopmath skill is installed (and which Codex form), whether it is current, and the
10
+ job skills 0.3.3 and older installed that are still on disk
10
11
 
11
12
  Nothing here opens a network connection. Log files are read through the
12
13
  parse cache, which doctor keeps up to date in the store's cache folder (the
@@ -189,28 +190,51 @@ def _install_cmd(place: dict) -> str:
189
190
  return f"loopmath skill install --target {place['target']} --scope {place['scope']}"
190
191
 
191
192
 
193
+ def _folders(paths: list[str]) -> str:
194
+ """The retired files, by the skill folder each is in (`loopmath/reference.md` by its name)."""
195
+ names = []
196
+ for path in paths:
197
+ folder, file = Path(path).parent.name, Path(path).name
198
+ name = f"{folder}/{file}" if folder == "loopmath" else folder
199
+ if name not in names:
200
+ names.append(name)
201
+ return ", ".join(names)
202
+
203
+
192
204
  def check_skill(cwd: Path | None, env: Mapping[str, str] | None) -> dict:
193
- """`ok` when the full set is installed and current for some target, with nothing old or partial
194
- left anywhere; else a warning with the exact install command."""
205
+ """`ok` when the skill is installed and current for some target, with nothing old, partial or
206
+ retired left anywhere; else a warning with the exact install command. Retired files loopmath still
207
+ owns go with that command; the others were kept, and the warning says why."""
195
208
  places = _install.status(cwd=cwd, env=env)
196
- n = len(_install.SKILLS)
197
209
  seen = [p for p in places if p["any"]]
198
210
  if not seen:
199
211
  return _check("skill", "warn", "not installed: run `loopmath skill install`", places=places)
200
212
  problems = []
201
213
  for p in seen:
202
214
  where = f"{p['target']} {p['scope']}"
215
+ retired = p["retired"]
203
216
  if p["old"]:
204
217
  problems.append(f"{where} still has the 0.1 single skill: run `{_install_cmd(p)}`")
205
218
  elif p["missing"]:
206
- problems.append(f"{where} lacks {', '.join(p['missing'])}: run `{_install_cmd(p)}`")
219
+ problems.append(f"{where} lacks the loopmath skill: run `{_install_cmd(p)}`")
207
220
  elif not p["current"]:
208
221
  problems.append(f"{where} is older than this loopmath: run `{_install_cmd(p)}`")
222
+ if retired["owned"]:
223
+ problems.append(f"{where} still has the job skills 0.3.3 and older installed "
224
+ f"({_folders(retired['owned'])}): run `{_install_cmd(p)}` to remove them")
225
+ if retired["changed"]:
226
+ problems.append(f"{where} kept {', '.join(retired['changed'])}: changed since loopmath wrote "
227
+ f"{'them' if len(retired['changed']) > 1 else 'it'}; move "
228
+ f"{'them' if len(retired['changed']) > 1 else 'it'} aside when no longer needed")
229
+ if retired["foreign"]:
230
+ problems.append(f"{where} has {', '.join(retired['foreign'])}, where 0.3.3 and older put job skills, "
231
+ "but loopmath did not write "
232
+ f"{'them' if len(retired['foreign']) > 1 else 'it'}: left alone")
209
233
  if problems:
210
234
  return _check("skill", "warn", "; ".join(problems), places=places)
211
235
  parts = [f"{p['target']} {p['scope']} ({'AGENTS.md block' if p['method'] == 'agents_block' else 'skills'})"
212
236
  for p in seen]
213
- return _check("skill", "ok", f"{n} skills: " + ", ".join(parts), places=places)
237
+ return _check("skill", "ok", "the loopmath skill: " + ", ".join(parts), places=places)
214
238
 
215
239
 
216
240
  def run_checks(home: Path, *, env: Mapping[str, str] | None = None, cwd: Path | None = None,
@@ -0,0 +1,52 @@
1
+ """`loopmath guide [TOPIC]`: the instructions for each job, for the agent to read and follow.
2
+
3
+ The one installed skill (`skills/loopmath/SKILL.md`) sends the agent here, so a job's
4
+ instructions always match the installed loopmath. Each topic is a packaged file in `guides/`:
5
+ the five jobs, then the command reference they share. Read only: it needs no store and writes
6
+ nothing, so this module imports nothing from the rest of loopmath.
7
+ """
8
+
9
+ from __future__ import annotations
10
+
11
+ import argparse
12
+ import sys
13
+ from importlib import resources
14
+
15
+ # Each topic, with one line on when to use it, in the order `loopmath guide` lists them.
16
+ TOPICS = {
17
+ "onboard": "set up, start or try loopmath from the user's Claude Code and Codex history, or loopmath has no runs yet",
18
+ "import": "OCP files or a folder of finished runs to bring into loopmath",
19
+ "plan": "a task to do: pick its workflow, models and effort, then start the run",
20
+ "record": "a task is done: record the run and show its receipt, or judge a pair blind",
21
+ "fit": "update the fit, say what loopmath learned, or the fit is not usable",
22
+ "reference": "every command, flag, JSON field and exit code the guides use",
23
+ }
24
+ FOLLOW = "Run `loopmath guide <topic>` and follow it."
25
+ EXIT_UNKNOWN = 2 # the CLI's "not found"
26
+
27
+
28
+ def text(topic: str) -> str:
29
+ """One topic's text, as packaged. KeyError on another name."""
30
+ if topic not in TOPICS:
31
+ raise KeyError(topic)
32
+ return resources.files("loopmath.skill").joinpath("guides", f"{topic}.md").read_text(encoding="utf-8")
33
+
34
+
35
+ def listing() -> str:
36
+ """What `loopmath guide` alone prints: each topic with when to use it, then how to read one."""
37
+ width = max(map(len, TOPICS))
38
+ rows = [f" {name:<{width}} {when}" for name, when in TOPICS.items()]
39
+ return "loopmath guides, one per job, and the command reference:\n\n" + "\n".join(rows) + f"\n\n{FOLLOW}\n"
40
+
41
+
42
+ def command(args: argparse.Namespace) -> int:
43
+ topic = getattr(args, "topic", None)
44
+ if topic is None:
45
+ sys.stdout.write(listing())
46
+ return 0
47
+ try:
48
+ sys.stdout.write(text(topic))
49
+ except KeyError:
50
+ print(f"error: no guide {topic!r}; the topics are {', '.join(TOPICS)}. {FOLLOW}", file=sys.stderr)
51
+ return EXIT_UNKNOWN
52
+ return 0
@@ -1,14 +1,8 @@
1
- ---
2
- name: loopmath-update-fit
3
- description: "Refit loopmath on every run recorded so far and show the results page. Use when the user asks to update, refresh or rerun the loopmath fit, asks what loopmath learned or believes about models, efforts or workflows, or after runs were imported or recorded without a refit."
4
- allowed-tools: Bash(loopmath:*), Bash(open:*), Bash(xdg-open:*)
5
- ---
6
-
7
1
  # Update the loopmath fit
8
2
 
9
3
  Refit on everything in the store, then show the results page. No question.
10
4
 
11
- Use exactly the commands below. Flags and fields are in `reference.md` next to this file. Never run `--help`.
5
+ Use exactly the commands below. Flags and fields are in `loopmath guide reference`. Never run `--help`.
12
6
 
13
7
  ## 1. Fit
14
8
 
@@ -24,7 +18,7 @@ A new fit replaces the one `recommend` and the pages read. Read `fit.id`, `fit.n
24
18
 
25
19
  `shipped_overlap` counts, per shipped source, the user's runs that the shipped prior also holds (the same runs); the fit uses the user's copies. When it has counts, the summary says one line, once: "N of your runs are also in the shipped SOURCE prior (same runs): fits use your copies", with the total for N ("1 of your runs is also in the shipped SOURCE prior (same run): fits use your copy" for one run), and with several sources "the shipped prior (rq1 40, e0 4)" for "the shipped SOURCE prior". Its `dropped` reason, "shipped copy of a stored run", is that same overlap: do not name it again.
26
20
 
27
- If it exits 4 (another fit holds the lock), wait 30 seconds and run it once more. If `fit.n_runs.user` is 0 and the user expected runs, say so and suggest `loopmath-onboard` or `loopmath-import-runs`.
21
+ If it exits 4 (another fit holds the lock), wait 30 seconds and run it once more. If `fit.n_runs.user` is 0 and the user expected runs, say so and suggest onboarding (`loopmath guide onboard`) or bringing existing runs (`loopmath guide import`).
28
22
 
29
23
  ## 2. Show the results page
30
24
 
@@ -1,14 +1,8 @@
1
- ---
2
- name: loopmath-import-runs
3
- description: "Bring agent runs the user already has as OCP files (*.ocp.json) into loopmath in one pass: validate all, import all, fit once, show the results page. Use when the user points at OCP files or a folder of finished runs, or at the output of an orchestrator or experiment harness that writes OCP, and wants loopmath to learn from them."
4
- allowed-tools: Bash(loopmath:*), Bash(open:*), Bash(xdg-open:*)
5
- ---
6
-
7
1
  # Bring existing runs into loopmath
8
2
 
9
3
  The user has finished runs written as OCP v0.3 (or v0.1, v0.2) documents. Validate them all, import them all without refitting after each, fit once, and show the results page. Ask nothing unless the location of the files is unknown.
10
4
 
11
- Use exactly the commands below. Flags and fields are in `reference.md` next to this file. Never run `--help`.
5
+ Use exactly the commands below. Flags and fields are in `loopmath guide reference`. Never run `--help`.
12
6
 
13
7
  ## 1. Find the files
14
8
 
@@ -1,14 +1,8 @@
1
- ---
2
- name: loopmath-onboard
3
- description: "Set the user up with loopmath from their own Claude Code and Codex history, in one pass: one question (which model labels their sessions, with its cost), then onboarding, the first fit and the results page. Use when the user asks to onboard, set up, start or try loopmath, or when loopmath has no runs yet."
4
- allowed-tools: Bash(loopmath:*), Bash(open:*), Bash(xdg-open:*)
5
- ---
6
-
7
1
  # Onboard the user with loopmath
8
2
 
9
3
  Onboarding reads the user's past Claude Code and Codex sessions (read only), groups them into tasks, has a model the user chooses name each task's type, records one run per task, finds the usual workflow per task type and repo, and fits. You ask one question, the labeller with its cost, and do the rest without stopping.
10
4
 
11
- Use exactly the commands below. Flags and fields are in `reference.md` next to this file. Never run `--help`.
5
+ Use exactly the commands below. Flags and fields are in `loopmath guide reference`. Never run `--help`.
12
6
 
13
7
  ## 1. Look first (no question yet)
14
8
 
@@ -22,7 +16,7 @@ Read `prior.line`, `groups.total`, `groups.to_label`, `window.from`, `window.to`
22
16
 
23
17
  Show the user `prior.line` once, word for word. It says what the answers start from before any of their runs, the prior that ships inside loopmath: its version, its runs per source, the published benchmarks it holds and the date it was built. Do not repeat it later, and do not write the numbers yourself: they change with each release. `loopmath prior show` lists the same prior source by source.
24
18
 
25
- If `groups.to_label` is 0, there is nothing to label. Do not ask anything. Say what was found (`groups.total` groups, none with a prompt to label, or no sessions in the window), run `loopmath fit --json`, and go to step 4. Suggest `loopmath-import-runs` if the user has OCP files.
19
+ If `groups.to_label` is 0, there is nothing to label. Do not ask anything. Say what was found (`groups.total` groups, none with a prompt to label, or no sessions in the window), run `loopmath fit --json`, and go to step 4. If the user has OCP files, offer to bring them in (`loopmath guide import`).
26
20
 
27
21
  ## 2. Ask one question
28
22
 
@@ -1,21 +1,15 @@
1
- ---
2
- name: loopmath-plan-task
3
- description: "Choose the workflow, models and effort for one coding task with loopmath, then start it: recommend, show the ready choices with chance and cost, ask one question, open the run. Use when the user asks to plan a task or an implementation with loopmath, asks which workflow, model or effort to use, pastes an option from a loopmath planning page (option 2: ...), or starts a coding task of more than a few minutes of agent work in a repo where they use loopmath."
4
- allowed-tools: Bash(loopmath:*), Bash(git rev-parse:*), Bash(git remote get-url:*), Bash(open:*), Bash(xdg-open:*)
5
- ---
6
-
7
1
  # Plan a task with loopmath
8
2
 
9
3
  One pass: classify the task, ask loopmath, show its choices, ask one question, start the chosen run, then do the work. The user makes one choice; you type everything else.
10
4
 
11
- Use exactly the commands below. Flags and fields are in `reference.md` next to this file. Never run `--help`.
5
+ Use exactly the commands below. Flags and fields are in `loopmath guide reference`. Never run `--help`.
12
6
 
13
7
  ## 1. Classify the task (no question)
14
8
 
15
9
  From the user's words and the repo, decide:
16
10
  - `TYPE`: one of `bug_fix`, `feature`, `refactor`, `tests`, `docs`, `research`, `infra`, `data`;
17
11
  - `TITLE`: the task in at most 60 characters;
18
- - features you can tell: `size`, `lang`, `has_tests`, `spec_clarity`, `needs_design`, `touches` (values in `reference.md`). Leave out the rest;
12
+ - features you can tell: `size`, `lang`, `has_tests`, `spec_clarity`, `needs_design`, `touches` (values in `loopmath guide reference`). Leave out the rest;
19
13
  - a target, only when the user states a score or runtime goal: `--target 'heldout_perf>=2400'`.
20
14
 
21
15
  Then the repo and the base commit. When the user names the repo ("in ale-bench", "for acme/api"), `REPO` is that name, lowercased. In the folder you work in:
@@ -111,7 +105,7 @@ Run the pieces in order, each with its setting from `piece_settings`. Note every
111
105
  - **Width above 1:** launch that many agents for the piece, each with its own session.
112
106
  - **Pair:** both runs start from `SHA` in separate git worktrees (`git worktree add ../TASK-a SHA`, `../TASK-b SHA`; with no git checkout, two copies of the folder), and both finish before any judging.
113
107
 
114
- When the work is done, follow `loopmath-record-run`.
108
+ When the work is done, run `loopmath guide record` and follow it.
115
109
 
116
110
  ## Never
117
111
 
@@ -1,14 +1,8 @@
1
- ---
2
- name: loopmath-record-run
3
- description: "Record a finished agent run in loopmath with one command, from the session ids noted while the work ran, with test results and scores, then show the receipt: predicted against actual cost, and the outcome. Use when a task planned with loopmath is done, when the user asks to record, log or save a run in loopmath, or when both runs of a loopmath pair are done and need a blind judge."
4
- allowed-tools: Bash(loopmath:*), Bash(open:*), Bash(xdg-open:*)
5
- ---
6
-
7
1
  # Record a run with loopmath
8
2
 
9
3
  One command records the whole run: one attempt per session (a Claude Code session counts its sub-agents), the commits made since the base commit, the verdicts and scores, the cost from the logs, the receipt and a background refit. Ask nothing unless you cannot tell which sessions did the work.
10
4
 
11
- Use exactly the commands below, and read their JSON as printed. Flags and fields are in `reference.md` next to this file. Never run `--help`.
5
+ Use exactly the commands below, and read their JSON as printed. Flags and fields are in `loopmath guide reference`. Never run `--help`.
12
6
 
13
7
  ## 1. Gather what the command needs (no question)
14
8
 
@@ -56,7 +50,7 @@ The second line is `receipt.line`. Report every `unmatched` entry and every note
56
50
 
57
51
  ## 4. Pairs: judge blind, after both runs are recorded
58
52
 
59
- When the run belongs to a slate (a pair from `loopmath-plan-task`) and both runs are recorded:
53
+ When the run belongs to a slate (a pair started as `loopmath guide plan` says) and both runs are recorded:
60
54
 
61
55
  1. `loopmath config get referee.model --json`: launch a fresh agent of that family (a family other than both runs' implementers when `value` is null).
62
56
  2. Give it the task and the two diffs in random order as A and B, without run ids, workflow names or models, with this prompt:
@@ -1,6 +1,6 @@
1
1
  # loopmath reference for agents
2
2
 
3
- Shared by every loopmath skill; `loopmath skill install` puts a copy next to each `SKILL.md`, and `loopmath skill show reference` prints it. Every command, flag and JSON field the skills use is here. Never run loopmath or any of its commands with `--help`: if something is missing here, run `loopmath doctor --json` and tell the user.
3
+ Shared by every loopmath guide; `loopmath guide reference` prints it. Every command, flag and JSON field the guides use is here. Never run loopmath or any of its commands with `--help`: if something is missing here, run `loopmath doctor --json` and tell the user.
4
4
 
5
5
  ## Conventions
6
6
 
@@ -70,7 +70,7 @@ loopmath recommend --type TYPE --repo REPO --title "TEXT" --feature size=m --bas
70
70
  - Up to 5 choices. Their order in `choices[]` is the order to number them in: each has `option`, its number from 1, the same number the planning page shows. The page's "Copy option" button copies `option N: LABEL`; a user who pastes it means the choice with that `label`; when no choice has that label (a page from another recommendation), show the current choices and ask, and never start another workflow in its place. For a row that is not a numbered option it copies `workflow CFG: LABEL`: start that configuration with `--config CFG` (Run start, below).
71
71
  - `most_likely` (with a score target): the workflow with the highest chance to reach the target. Left out when it is already another choice.
72
72
  - `p_accepted_within` on each choice (and in each `numbers` object): `mean`, `lo`, `hi`, `attempts`: the chance of an accepted result within `attempts` attempts, the first run and its retries (a ceiling: retries have less and less chance). Show it apart from `chance`, the chance of one run.
73
- - `bands` on each choice (and in each `numbers` object) in the full `--json`, the stored recommendation and the page data, not in `--brief`: central intervals, `chance`, `run_cost_usd` and `cost_per_accepted_usd`, each `{"50": [lo, hi], "80": [...], "90": [...], "95": [...]}`; a missing level is an absent key. For the pages; the skills show the 80% range from `lo` and `hi`.
73
+ - `bands` on each choice (and in each `numbers` object) in the full `--json`, the stored recommendation and the page data, not in `--brief`: central intervals, `chance`, `run_cost_usd` and `cost_per_accepted_usd`, each `{"50": [lo, hi], "80": [...], "90": [...], "95": [...]}`; a missing level is an absent key. For the pages; the guides show the 80% range from `lo` and `hi`.
74
74
  - There is a `pair` choice only when a second workflow is worth trying beside the goal; without one, `message` says so, and `run start --choice` takes only the keys in `choices[]`. The `pair` choice adds `explore_config` (the second member), `price_now_usd` (the extra run's cost now), `gain_per_future_run_usd` (the expected saving on each future similar run), `payback_runs` (similar runs until the extra run pays for itself: `price_now_usd` divided by `gain_per_future_run_usd`, rounded up, at least 1; null when the gain is 0; the number `message` says) and `p_beats_goal`.
75
75
  - `rescue`: how a missed run is fixed, which cost per accepted result counts. `kind` `retry` (the default): retry with another workflow, `of` (its label) and `config` (its id), chosen as the cheapest per run with at least `min_chance` (0.7) chance, else the most likely; `chance` (`mean`, `lo`, `hi`) and `run_cost_usd` are its own; each extra attempt has `decay` (0.5) times the chance of the one before, up to `max_attempts` (3) attempts in all, counting the first run; `p_accepted` is the chance the retries fix a miss; `usd` and `tokens` are the expected cost of fixing a miss; `basis` says how it was chosen; `text` is one plain sentence about it: quote it word for word. Older kinds: `redo_usual` (the reference repeated until accepted), `person` (a person's time), `none`. Without `text`, run cost is what the agents cost for one run, and cost per accepted result adds `expected_rescue_usd`, the expected cost of fixing a miss.
76
76
  - The `goal` choice adds `strategy`: null, or the try-then-rescue plan when the pick is less likely than the reference. Show `strategy.text` word for word. Its numbers are in `chance`, `misses`, `rescue`, `cost_per_accepted_usd` and `reference_cost_per_accepted_usd`. The same object is `goal.strategy`.
loopmath/skill/install.py CHANGED
@@ -1,30 +1,33 @@
1
- """Install the skill set for Claude Code and Codex, user and project scope (spec 07, section 1).
1
+ """Install the loopmath skill for Claude Code and Codex, user and project scope (spec 07, section 1).
2
2
 
3
- Six skills, one per job (`SKILLS`), each a folder with its `SKILL.md` and a copy of the shared
4
- `reference.md`:
3
+ One skill, `loopmath` (`SKILLS`), a folder with its `SKILL.md`; the instructions for each job
4
+ come from `loopmath guide` (guide.py), so they match the installed version:
5
5
 
6
- | target | scope | where each skill folder goes |
6
+ | target | scope | where the skill folder goes |
7
7
  |-------------|---------|---------------------------------------------------------------|
8
- | claude-code | user | ~/.claude/skills/<name>/ ($CLAUDE_CONFIG_DIR wins) |
9
- | claude-code | project | .claude/skills/<name>/ |
10
- | codex | user | ~/.codex/skills/<name>/ ($CODEX_HOME wins), or |
11
- | | | ~/.codex/loopmath/<name>/ and a marked block in |
12
- | | | ~/.codex/AGENTS.md listing the six |
13
- | codex | project | .codex/skills/<name>/, or .codex/loopmath/<name>/ and the |
8
+ | claude-code | user | ~/.claude/skills/loopmath/ ($CLAUDE_CONFIG_DIR wins) |
9
+ | claude-code | project | .claude/skills/loopmath/ |
10
+ | codex | user | ~/.codex/skills/loopmath/ ($CODEX_HOME wins), or |
11
+ | | | ~/.codex/loopmath/loopmath/ and a marked block in |
12
+ | | | ~/.codex/AGENTS.md naming it |
13
+ | codex | project | .codex/skills/loopmath/, or .codex/loopmath/loopmath/ and the |
14
14
  | | | block in AGENTS.md |
15
15
 
16
- Codex gets skill folders when it supports skills, which we read from the user's Codex skills
17
- folder existing (Codex creates it); otherwise the pointer block. The packaged sources carry
16
+ Codex gets the skill folder when it supports skills, which we read from the user's Codex skills
17
+ folder existing (Codex creates it); otherwise the pointer block. The packaged source carries
18
18
  Claude Code's frontmatter; Codex gets the same text without `allowed-tools`.
19
19
 
20
20
  Ownership is by manifest, never by a path alone. Install writes `.loopmath-skills.json` in the
21
21
  folder that holds the skill folders, with the sha256 of every file it wrote. Install, upgrade and
22
- uninstall touch only the twelve files of the set (exact names), and only when the manifest lists
23
- the file with its current hash, or the file already holds exactly what install would write. A
24
- listed file the user has changed is kept, with a note. Any other file in the way stops the whole
25
- install before its first write. The 0.1 single skill (`loopmath/SKILL.md`, and for Codex without
26
- skills `loopmath/SKILL.md` beside the block) is replaced or removed only when its hash is one
27
- loopmath 0.1 shipped (`LEGACY_SHA256`). In AGENTS.md only the text between the markers changes.
22
+ uninstall write only the skill's file (`OWNED`), and only when the manifest lists it with its
23
+ current hash, or it already holds exactly what install would write. A listed file the user has
24
+ changed is kept, with a note. Any other file in the way stops the whole install before its first
25
+ write. 0.2.0 to 0.3.3 installed six skills, each with a copy of a shared `reference.md`; install
26
+ and uninstall remove those eleven files (`RETIRED`) only where the manifest lists them with their
27
+ current hash, and keep the rest with a note. The 0.1 single skill (`loopmath/SKILL.md`, and for
28
+ Codex without skills `loopmath/SKILL.md` beside the block) is replaced or removed only when its
29
+ hash is one loopmath 0.1 shipped (`LEGACY_SHA256`). In AGENTS.md only the text between the
30
+ markers changes.
28
31
  """
29
32
 
30
33
  from __future__ import annotations
@@ -39,17 +42,11 @@ from importlib import resources
39
42
  from pathlib import Path
40
43
  from typing import Mapping
41
44
 
42
- SKILLS = ("loopmath", "loopmath-onboard", "loopmath-import-runs", "loopmath-update-fit", "loopmath-plan-task",
43
- "loopmath-record-run")
44
- TRIGGERS = { # one line each in the Codex pointer block
45
- "loopmath": "start here when the user mentions loopmath without naming a job",
46
- "loopmath-onboard": "onboard, set up or try loopmath from the user's history",
47
- "loopmath-import-runs": "bring existing OCP files or a folder of finished runs into loopmath",
48
- "loopmath-update-fit": "update the fit, or say what loopmath learned",
49
- "loopmath-plan-task": "plan a coding task: which workflow, model or effort, then start the run",
50
- "loopmath-record-run": "record a finished run, show its receipt, judge a pair",
51
- }
52
- REFERENCE = "reference.md"
45
+ SKILLS = ("loopmath",)
46
+ # The job skills 0.2.0 to 0.3.3 installed beside `loopmath`, and the `loopmath guide` topic that has each one's text now.
47
+ RETIRED_SKILLS = {"loopmath-onboard": "onboard", "loopmath-import-runs": "import", "loopmath-update-fit": "fit",
48
+ "loopmath-plan-task": "plan", "loopmath-record-run": "record"}
49
+ REFERENCE = "reference.md" # each of the six skill folders had a copy; now `loopmath guide reference`
53
50
  TARGETS = ("claude-code", "codex")
54
51
  TARGET_CHOICES = ("auto", "claude-code", "codex", "both")
55
52
  SCOPES = ("user", "project")
@@ -57,8 +54,9 @@ BLOCK_BEGIN = "<!-- loopmath -->"
57
54
  BLOCK_END = "<!-- /loopmath -->"
58
55
  MANIFEST = ".loopmath-skills.json"
59
56
  MANIFEST_SCHEMA = "loopmath.skill.manifest/1"
60
- OWNED = tuple(f"{name}/{file}" for name in SKILLS for file in ("SKILL.md", REFERENCE)) # the only files it touches
61
- LEGACY = "loopmath/SKILL.md" # where 0.1 put its single skill, now the start-here skill
57
+ OWNED = tuple(f"{name}/SKILL.md" for name in SKILLS) # the only files it writes
58
+ RETIRED = (f"loopmath/{REFERENCE}",) + tuple(f"{name}/{file}" for name in RETIRED_SKILLS for file in ("SKILL.md", REFERENCE))
59
+ LEGACY = "loopmath/SKILL.md" # where 0.1 put its single skill, and where the one skill goes now
62
60
  # sha256 of the single SKILL.md loopmath 0.1 wrote, the same text for every target and form.
63
61
  LEGACY_SHA256 = {
64
62
  "164e47ba206b15a978c13858b1c1839c05f06afb3afb533786bb94e1433857e1": "0.1.0",
@@ -86,20 +84,22 @@ def _package_file(*parts: str) -> str:
86
84
  return resources.files("loopmath.skill").joinpath("skills", *parts).read_text(encoding="utf-8")
87
85
 
88
86
 
89
- def reference_text() -> str:
90
- """The shared reference, as packaged."""
91
- return _package_file(REFERENCE)
92
-
93
-
94
87
  def skill_text(name: str = "loopmath") -> str:
95
- """One packaged skill (Claude Code form), or the reference for `reference`. KeyError on another name."""
96
- if name == "reference":
97
- return reference_text()
88
+ """The packaged skill (Claude Code form). KeyError on another name."""
98
89
  if name not in SKILLS:
99
90
  raise KeyError(name)
100
91
  return _package_file(name, "SKILL.md")
101
92
 
102
93
 
94
+ def description(text: str) -> str:
95
+ """The `description` in a skill's frontmatter, unquoted."""
96
+ head = text.split("\n---\n", 1)[0] if text.startswith("---\n") else ""
97
+ for line in head.splitlines():
98
+ if line.startswith("description:"):
99
+ return line.partition(":")[2].strip().strip('"')
100
+ return ""
101
+
102
+
103
103
  def _for_target(text: str, target: str) -> str:
104
104
  """Codex skills take `name` and `description` only: drop `allowed-tools` from the frontmatter."""
105
105
  if target != "codex" or not text.startswith("---\n"):
@@ -178,10 +178,11 @@ def _block_path(where: Placement, path: Path, cwd: Path | None) -> str:
178
178
 
179
179
 
180
180
  def pointer_block(where: Placement, cwd: Path | None = None) -> str:
181
+ """The marked AGENTS.md block: one entry, the skill's own description and where its file is."""
182
+ when = description(skill_text("loopmath")).rstrip(".")
181
183
  lines = [BLOCK_BEGIN, "## loopmath", "",
182
- "loopmath has one skill per job. Read the one that fits and follow it; "
183
- "`loopmath skill show NAME` prints the same text.", ""]
184
- lines += [f"- {TRIGGERS[name]}: `{_block_path(where, where.skill_md(name), cwd)}`" for name in SKILLS]
184
+ "loopmath has one skill. Read it and follow it; `loopmath skill show` prints the same text.", "",
185
+ f"- {when}: `{_block_path(where, where.skill_md('loopmath'), cwd)}`"]
185
186
  return "\n".join(lines) + f"\n{BLOCK_END}\n"
186
187
 
187
188
 
@@ -229,13 +230,8 @@ def _not_a_folder(path: Path) -> Path | None:
229
230
 
230
231
 
231
232
  def _want(target: str) -> dict[str, str]:
232
- """Every file of the set for `target`, by its path under the folder that holds the skill folders."""
233
- reference = reference_text()
234
- want = {}
235
- for skill, text in skill_texts(target).items():
236
- want[f"{skill}/SKILL.md"] = text
237
- want[f"{skill}/{REFERENCE}"] = reference
238
- return want
233
+ """Every file install writes for `target`, by its path under the folder that holds the skill folders."""
234
+ return {f"{skill}/SKILL.md": text for skill, text in skill_texts(target).items()}
239
235
 
240
236
 
241
237
  def _load_manifest(root: Path) -> dict:
@@ -261,12 +257,40 @@ def _save_manifest(root: Path, manifest: dict) -> None:
261
257
  path.unlink()
262
258
 
263
259
 
260
+ def _retired(where: Placement, listed: dict[str, str]) -> list[tuple[str, Path, str]]:
261
+ """(path under root, path, how) for each retired file on disk in `where`: `owned` when the manifest
262
+ lists it with its current hash, so install and uninstall remove it; `changed` when listed with another
263
+ hash, and `foreign` when not listed, both kept."""
264
+ out = []
265
+ for rel in RETIRED:
266
+ path = where.root / rel
267
+ cur = _state(path)
268
+ if cur is None:
269
+ continue
270
+ how = "owned" if cur and listed.get(rel) == cur else ("changed" if rel in listed else "foreign")
271
+ out.append((rel, path, how))
272
+ return out
273
+
274
+
275
+ def guide_for(rel: str) -> str:
276
+ """The `loopmath guide` topic that holds a retired file's text now."""
277
+ folder, _, file = rel.partition("/")
278
+ return "reference" if file == REFERENCE else RETIRED_SKILLS[folder]
279
+
280
+
281
+ def _retired_note(rel: str, path: Path, how: str) -> str:
282
+ why = "changed since loopmath wrote it" if how == "changed" else "loopmath did not write it"
283
+ return (f"kept {path}: {why}; 0.3.4 no longer installs it (`loopmath guide {guide_for(rel)}` has its text), "
284
+ "so move it aside when you no longer need it")
285
+
286
+
264
287
  def _plan(where: Placement, want: dict[str, str]) -> tuple[dict, list[dict], list[str]]:
265
288
  """What install would do in `where`, before any write: (the manifest, one step per file, the paths
266
289
  in the way). A file is loopmath's when the manifest lists it with its current hash, or when it
267
290
  already holds exactly what install writes; the 0.1 single skill, when its hash is one 0.1 shipped.
268
291
  A listed file with another hash was changed by someone and is kept. A file where a folder must be
269
- (a skill folder, or one above it), and a folder or a dangling link at AGENTS.md, are in the way too."""
292
+ (a skill folder, or one above it), and a folder or a dangling link at AGENTS.md, are in the way too.
293
+ The retired files are not in the way: they are removed or kept after the writes (`_retired`)."""
270
294
  manifest = _load_manifest(where.root)
271
295
  listed = manifest["files"]
272
296
  steps, blocked = [], []
@@ -307,12 +331,11 @@ def _blocked(paths: list[str]) -> str:
307
331
 
308
332
 
309
333
  def _entry(result: dict, rel: str, path: Path | str, action: str) -> None:
310
- """File one step under `skills` or `reference`."""
311
- skill, _, file = rel.partition("/")
312
- if file == REFERENCE:
313
- result["reference"].append({"path": str(path), "action": action})
314
- else:
315
- result["skills"].append({"name": skill, "path": str(path), "action": action})
334
+ """File one step: the skill under `skills`, a retired file removed under `removed`."""
335
+ if rel in OWNED:
336
+ result["skills"].append({"name": rel.partition("/")[0], "path": str(path), "action": action})
337
+ elif action == "removed":
338
+ result["removed"].append({"path": str(path), "action": action})
316
339
 
317
340
 
318
341
  # A file of the set with no manifest entry that already holds exactly the text install writes.
@@ -378,10 +401,16 @@ def _retire_legacy(path: Path, notes: list[str], dry_run: bool = False) -> str |
378
401
  return "kept"
379
402
 
380
403
 
404
+ def _folders() -> list[str]:
405
+ """Every skill folder the set and the retired files were in, in `OWNED` then `RETIRED` order."""
406
+ return list(dict.fromkeys(rel.partition("/")[0] for rel in OWNED + RETIRED))
407
+
408
+
381
409
  def _remove_owned(where: Placement, notes: list[str], dry_run: bool = False) -> list[tuple[str, Path, str]]:
382
- """Remove each file of the set in `where` that is loopmath's (as `_plan` decides) and keep the rest,
383
- with a note. Returns (path under root, path, action) per file of the set; the manifest keeps only
384
- the files that stay. A dry run changes nothing and returns the same."""
410
+ """Remove the skill in `where` when it is loopmath's (as `_plan` decides), and each retired file the
411
+ manifest lists with its current hash; keep the rest, with a note. Returns (path under root, path,
412
+ action) for the skill, and for each retired file on disk; the manifest keeps only the files that
413
+ stay. A dry run changes nothing and returns the same."""
385
414
  manifest = _load_manifest(where.root)
386
415
  listed = manifest["files"]
387
416
  want = _want(where.target)
@@ -404,9 +433,21 @@ def _remove_owned(where: Placement, notes: list[str], dry_run: bool = False) ->
404
433
  action = "kept"
405
434
  notes.append(_kept(path, rel in listed))
406
435
  out.append((rel, path, action))
436
+ for rel in RETIRED:
437
+ if _state(where.root / rel) is None:
438
+ listed.pop(rel, None)
439
+ for rel, path, how in _retired(where, listed):
440
+ if how == "owned":
441
+ if not dry_run:
442
+ path.unlink()
443
+ listed.pop(rel, None)
444
+ out.append((rel, path, "removed"))
445
+ else:
446
+ notes.append(_retired_note(rel, path, how))
447
+ out.append((rel, path, "kept"))
407
448
  if dry_run:
408
449
  return out
409
- for skill in SKILLS:
450
+ for skill in _folders():
410
451
  _rmdir_empty(where.root / skill)
411
452
  _save_manifest(where.root, manifest)
412
453
  return out
@@ -421,10 +462,20 @@ def _preflight(target: str, scope: str, cwd: Path | None, env: Mapping[str, str]
421
462
 
422
463
 
423
464
  def _result(where: Placement) -> dict:
424
- return {**where.to_dict(), "manifest": str(where.root / MANIFEST), "skills": [], "reference": [],
465
+ return {**where.to_dict(), "manifest": str(where.root / MANIFEST), "manifest_action": None, "skills": [],
425
466
  "removed": [], "block": None, "notes": []}
426
467
 
427
468
 
469
+ def _manifest_action(root: Path, before: dict[str, str], after: dict[str, str]) -> str:
470
+ """What saving the manifest does to its file: created, updated, removed or unchanged."""
471
+ exists = (root / MANIFEST).is_file()
472
+ if not after:
473
+ return "removed" if exists else "unchanged"
474
+ if not exists:
475
+ return "created"
476
+ return "unchanged" if after == before else "updated"
477
+
478
+
428
479
  def install(target: str = "auto", scope: str = "user", *, cwd: Path | None = None,
429
480
  env: Mapping[str, str] | None = None, dry_run: bool = False) -> list[dict]:
430
481
  """Install the set for one target, `both` or `auto`. Returns one result per target. Every target is
@@ -446,6 +497,7 @@ def install(target: str = "auto", scope: str = "user", *, cwd: Path | None = Non
446
497
  result = _result(where)
447
498
  if dry_run:
448
499
  result["dry_run"] = True
500
+ before = dict(manifest["files"])
449
501
  for step in steps:
450
502
  if step["action"] in ("created", "updated", "replaced") and not dry_run:
451
503
  _write_atomic(step["path"], step["text"])
@@ -458,7 +510,21 @@ def install(target: str = "auto", scope: str = "user", *, cwd: Path | None = Non
458
510
  result["notes"].append(_ADOPTED.format(path=step["path"], verb="would take" if dry_run else "took",
459
511
  tense="holds"))
460
512
  _entry(result, step["rel"], step["path"], step["action"])
513
+ for rel in RETIRED: # 0.2.0 to 0.3.3's job skills and reference copies: gone where loopmath still owns them
514
+ if _state(where.root / rel) is None:
515
+ manifest["files"].pop(rel, None)
516
+ for rel, path, how in _retired(where, manifest["files"]):
517
+ if how == "owned":
518
+ if not dry_run:
519
+ path.unlink()
520
+ manifest["files"].pop(rel, None)
521
+ _entry(result, rel, path, "removed")
522
+ else:
523
+ result["notes"].append(_retired_note(rel, path, how))
524
+ result["manifest_action"] = _manifest_action(where.root, before, manifest["files"])
461
525
  if not dry_run:
526
+ for skill in _folders():
527
+ _rmdir_empty(where.root / skill)
462
528
  _save_manifest(where.root, manifest)
463
529
  if where.method == "agents_block":
464
530
  if _retire_legacy(where.root / "SKILL.md", result["notes"], dry_run) == "removed":
@@ -534,9 +600,10 @@ def uninstall(target: str = "auto", scope: str = "user", *, cwd: Path | None = N
534
600
 
535
601
 
536
602
  def status(*, cwd: Path | None = None, env: Mapping[str, str] | None = None) -> list[dict]:
537
- """Where the set is installed, for `doctor`: one entry per target and scope."""
603
+ """Where the skill is installed, for `doctor`: one entry per target and scope. `retired` lists the
604
+ retired files still on disk there by how they stand (`_retired`), and with a broken manifest every
605
+ one of them as `foreign`."""
538
606
  env = os.environ if env is None else env
539
- reference = reference_text()
540
607
  out = []
541
608
  for name in TARGETS:
542
609
  texts = skill_texts(name)
@@ -546,17 +613,23 @@ def status(*, cwd: Path | None = None, env: Mapping[str, str] | None = None) ->
546
613
  block = True
547
614
  if where.method == "agents_block":
548
615
  try:
549
- block = where.agents_md.is_file() and \
550
- _split_block(where.agents_md.read_text(encoding="utf-8"))[1] is not None
616
+ found = _split_block(where.agents_md.read_text(encoding="utf-8"))[1] \
617
+ if where.agents_md.is_file() else None
618
+ block = found == pointer_block(where, cwd)
551
619
  except ValueError:
552
620
  block = False
553
621
  old = _state(where.root / LEGACY) in LEGACY_SHA256 or (where.method == "agents_block"
554
622
  and _state(where.root / "SKILL.md") in LEGACY_SHA256)
555
- current = all(where.skill_md(s).read_text(encoding="utf-8") == texts[s]
556
- and (where.root / s / REFERENCE).is_file()
557
- and (where.root / s / REFERENCE).read_text(encoding="utf-8") == reference
558
- for s in present)
623
+ current = all(where.skill_md(s).read_text(encoding="utf-8") == texts[s] for s in present)
624
+ try:
625
+ listed = _load_manifest(where.root)["files"]
626
+ except ValueError:
627
+ listed = {}
628
+ retired: dict[str, list[str]] = {"owned": [], "changed": [], "foreign": []}
629
+ for _, path, how in _retired(where, listed):
630
+ retired[how].append(str(path))
559
631
  out.append({**where.to_dict(), "installed": len(present) == len(SKILLS) and block,
560
- "any": bool(present) or old, "missing": [s for s in SKILLS if s not in present],
561
- "current": bool(present) and current and block, "old": old})
632
+ "any": bool(present) or old or any(retired.values()),
633
+ "missing": [s for s in SKILLS if s not in present],
634
+ "current": bool(present) and current and block, "old": old, "retired": retired})
562
635
  return out
@@ -1,35 +1,57 @@
1
1
  ---
2
2
  name: loopmath
3
- description: "Start here when the user mentions loopmath without naming a job, for example 'use loopmath', 'use the loopmath skill', 'what can loopmath do' or 'what next with loopmath'. Checks the store in one command and moves straight into the right job: onboarding, bringing existing runs, updating the fit, planning a task or recording a run."
4
- allowed-tools: Bash(loopmath:*)
3
+ description: Use whenever the user mentions loopmath.
4
+ allowed-tools: Bash(loopmath:*), Bash(git rev-parse:*), Bash(git remote get-url:*), Bash(open:*), Bash(xdg-open:*)
5
5
  ---
6
6
 
7
- # loopmath: start here
7
+ # loopmath
8
8
 
9
- loopmath helps choose the workflow, models and effort for coding agent tasks, and learns from how the runs went. It predicts, records and refits. It never starts agents itself. Every command you need is in the loopmath skills and in `reference.md` next to this file; never run `--help`.
9
+ ## What loopmath is
10
10
 
11
- ## Do this
11
+ loopmath is a command line tool that helps choose how to run a coding agent task: which workflow, which models and how much effort. It does three things:
12
12
 
13
- 1. Run `loopmath status --json`. Read `exists`, `counts.runs`, `open_runs[]`, `fit.latest`, `fit.usable`, `fit.problem`. If `loopmath` is not found, tell the user to install it (`pipx install loopmath` or `uv tool install loopmath`) and stop.
13
+ - **Predicts.** For a task, it estimates each workflow's chance of meeting the task's tests or stated target, and what it costs.
14
+ - **Records.** When a task is done, it stores what ran, what it cost and whether the result was accepted.
15
+ - **Refits.** From every recorded run it updates its estimates, so the next prediction is better.
14
16
 
15
- 2. Pick the job from what the user said, then from the store, and follow that skill at once without asking:
17
+ Three words come up everywhere:
16
18
 
17
- | The user said, or the store shows | Job (skill) |
18
- |---|---|
19
- | set up, onboard, start, try | `loopmath-onboard` |
20
- | names OCP files, a folder of runs, an experiment's output | `loopmath-import-runs` |
21
- | update, refresh or rerun the fit; what did loopmath learn | `loopmath-update-fit` |
22
- | a task to do, which workflow, model or effort to use, or `option N: ...` pasted from a planning page | `loopmath-plan-task` |
23
- | a task is done, or record, log or save a run | `loopmath-record-run` |
24
- | nothing specific, and `exists` is false or `counts.runs` is 0 | `loopmath-onboard` |
25
- | nothing specific, and `open_runs` is not empty | `loopmath-record-run` for those runs |
26
- | nothing specific, and `fit.latest` is set but `fit.usable` is false (say `fit.problem` in one line) | `loopmath-update-fit` |
27
- | nothing specific otherwise | tell the user in 3 lines what loopmath knows (`counts.runs` runs, fit `fit.latest`), then offer: plan the next task, bring existing runs, or see the results page (`loopmath posterior --html`) |
19
+ - A **workflow** is how a task is done: a shape such as `solo`, `plan_implement` or `implement_review`, plus the agent, model and effort for each piece.
20
+ - A **run** is one task done with one workflow: the agent sessions that did the work, their cost and the outcome.
21
+ - A **fit** is loopmath's current estimate of each workflow's chance and cost, with ranges. It is built from the user's recorded runs plus a starting estimate that ships inside loopmath.
28
22
 
29
- 3. When the job's skill is not loaded, read its `SKILL.md` in the sibling folder (for example `../loopmath-onboard/SKILL.md`) and follow it.
23
+ loopmath never starts agents itself. It recommends; you start the agents, and only for the workflow the user chose.
30
24
 
31
- ## Never
25
+ ## How to learn each job
32
26
 
33
- - Do not start agents because loopmath said so, without the user's choice.
34
- - Do not edit files under `~/.loopmath` or `$LOOPMATH_HOME` by hand.
35
- - Do not record another person's sessions.
27
+ The step by step instructions for each job come from the CLI: `loopmath guide <topic>`. A guide call only prints instructions; it never runs the job or changes anything. The guides ship inside the installed loopmath, so they always match its commands and JSON output, even after an upgrade. Read a job's guide in full before running the commands it names, then follow it. `loopmath guide` alone lists every topic.
28
+
29
+ Do not run loopmath commands with `--help`: the help text is written for people at a terminal and lists options the guides leave out on purpose. If a guide seems to miss something, run `loopmath doctor --json` and tell the user.
30
+
31
+ ## What to do first
32
+
33
+ 1. Run `loopmath status --json`. If `loopmath` is not found, tell the user to install it with `uv tool install --python 3.12 loopmath`, and stop.
34
+ 2. Pick the guide from what the user asked for:
35
+
36
+ | When | Run and follow |
37
+ |---|---|
38
+ | set up, start or try loopmath | `loopmath guide onboard` |
39
+ | OCP files or a folder of finished runs to bring in | `loopmath guide import` |
40
+ | a task to do, or which workflow, model or effort to use | `loopmath guide plan` |
41
+ | a task is done: record its run, or judge two runs blind | `loopmath guide record` |
42
+ | update the fit, or what loopmath learned | `loopmath guide fit` |
43
+ | a command, flag, JSON field or exit code you need | `loopmath guide reference` |
44
+
45
+ For example, if you need to onboard the user, run `loopmath guide onboard` and follow its output.
46
+
47
+ 3. If the user named no job, decide from the status, in this order:
48
+ - no store (`exists` false) or no runs (`counts.runs` 0): onboard;
49
+ - `open_runs` not empty: record, but only runs whose work is done;
50
+ - `fit.usable` false: fit, and say `fit.problem` in one line;
51
+ - otherwise say in three lines what loopmath knows (how many runs, which fit) and offer to plan the next task, bring in existing runs, or open the results page (`loopmath posterior --html`).
52
+
53
+ ## Rules that always hold
54
+
55
+ - Never start agents or a run without the user's choice. A recommendation is advice, not a choice.
56
+ - Never edit the store (`~/.loopmath`, or `$LOOPMATH_HOME`) by hand. Only loopmath commands write there.
57
+ - Never record another person's sessions.
@@ -1,8 +1,8 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: loopmath
3
- Version: 0.3.2
3
+ Version: 0.3.4
4
4
  Summary: Plan agent workflows, record how they went, and learn from your own Claude Code and Codex logs
5
- Author: QKV Labs
5
+ Author: loopmath
6
6
  License-Expression: MIT
7
7
  Project-URL: Homepage, https://github.com/loopmath/loopmath
8
8
  Project-URL: Issues, https://github.com/loopmath/loopmath/issues
@@ -73,20 +73,21 @@ loopmath skill install # teach your coding agents how to use loopmat
73
73
 
74
74
  Then ask your agent to onboard, for example "onboard loopmath". The agent runs a dry run, asks you one question (which model labels your sessions, with the cost of each option), onboards, fits, and opens the results page.
75
75
 
76
- `skill install` writes six skills, one per job. Each skill's folder also gets its own copy of the shared `reference.md`, with every command and JSON field the skills use, so each skill works on its own. An agent loads only the skill for the job at hand, and each phrase belongs to one skill:
76
+ `skill install` writes one skill, `loopmath`. It tells the agent to check the store with `loopmath status --json`, pick the job, and read that job's guide from the CLI, so the instructions always match the loopmath you have installed. Mention loopmath in what you ask, and the skill picks the guide:
77
77
 
78
- | Skill | Ask your agent |
78
+ | Guide | Ask your agent |
79
79
  |---|---|
80
- | `loopmath` | loopmath named without a job: "use loopmath", "what can loopmath do", "what next with loopmath" |
81
- | `loopmath-onboard` | "onboard", "set up", "start" or "try" loopmath; or loopmath has no runs yet |
82
- | `loopmath-import-runs` | OCP files (`*.ocp.json`), a folder of finished runs, or the output of an orchestrator or experiment harness that writes OCP |
83
- | `loopmath-update-fit` | "update", "refresh" or "rerun" the fit; what loopmath learned; runs imported or recorded without a refit |
84
- | `loopmath-plan-task` | "plan a task with loopmath"; which workflow, model or effort to use; a coding task of more than a few minutes in a repo that uses loopmath |
85
- | `loopmath-record-run` | a task planned with loopmath is done; "record", "log" or "save" a run; both runs of a pair need a blind judge |
80
+ | `loopmath guide onboard` | "onboard", "set up", "start" or "try" loopmath; or loopmath has no runs yet |
81
+ | `loopmath guide import` | OCP files (`*.ocp.json`), a folder of finished runs, or the output of an orchestrator or experiment harness that writes OCP |
82
+ | `loopmath guide plan` | "plan a task with loopmath"; which workflow, model or effort to use |
83
+ | `loopmath guide record` | a task planned with loopmath is done; "record", "log" or "save" a run; both runs of a pair need a blind judge |
84
+ | `loopmath guide fit` | "update", "refresh" or "rerun" the fit; what loopmath learned; runs imported or recorded without a refit |
86
85
 
87
- By default the skills go to every agent whose home exists: Claude Code (`~/.claude/skills/<name>/`, or under `$CLAUDE_CONFIG_DIR`) and Codex (`~/.codex/skills/<name>/`, or under `$CODEX_HOME`). `--target claude-code`, `codex` or `both` picks them yourself. If your Codex has no skills folder, the files go to `~/.codex/loopmath/<name>/` instead, with a short marked block in `~/.codex/AGENTS.md` that lists them. Add `--scope project` to install into the current repository (or `--dir PATH` for another one).
86
+ `loopmath guide` alone lists them, and `loopmath guide reference` prints the command reference they share, with every command, flag and JSON field they use. A guide is read only: it needs no store and writes nothing.
88
87
 
89
- It is safe to run again. It records the files it wrote, with their hashes, in `.loopmath-skills.json` beside the skill folders, and it replaces or removes only those. A skill file you changed is kept, with a note. Any other file where a skill goes stops the install before it writes anything, and names the path to move aside. The single skill that 0.1 installed is replaced when it is as 0.1 wrote it. `loopmath skill show NAME` prints one skill, and `loopmath skill uninstall` removes the files it wrote. `loopmath doctor` shows what loopmath can see: logs, agents, store, fit, prices and skills. To read the logs it builds the log parse cache in the store and keeps it, so the next read is fast, and it says how big the cache is; it changes nothing else in the store.
88
+ By default the skill goes to every agent whose home exists: Claude Code (`~/.claude/skills/loopmath/`, or under `$CLAUDE_CONFIG_DIR`) and Codex (`~/.codex/skills/loopmath/`, or under `$CODEX_HOME`). `--target claude-code`, `codex` or `both` picks them yourself. If your Codex has no skills folder, the skill goes to `~/.codex/loopmath/loopmath/` instead, with a short marked block in `~/.codex/AGENTS.md` that points to it. Add `--scope project` to install into the current repository (or `--dir PATH` for another one).
89
+
90
+ It is safe to run again. It records the files it wrote, with their hashes, in `.loopmath-skills.json` beside the skill folder, and it replaces or removes only those. A skill file you changed is kept, with a note. Any other file where the skill goes stops the install before it writes anything, and names the path to move aside. The single skill that 0.1 installed is replaced when it is as 0.1 wrote it. Upgrading from 0.2 or 0.3 removes the five job skills those versions installed and the `reference.md` copy in each skill folder, where loopmath wrote them and they are unchanged; a file you changed is kept, with a note. `--dry-run` lists every file install would write or remove. `loopmath skill show` prints the skill, and `loopmath skill uninstall` removes the files it wrote. `loopmath doctor` shows what loopmath can see: logs, agents, store, fit, prices and the skill, and names any job skill an older loopmath left behind. To read the logs it builds the log parse cache in the store and keeps it, so the next read is fast, and it says how big the cache is; it changes nothing else in the store.
90
91
 
91
92
  To onboard by hand instead:
92
93
 
@@ -112,7 +113,7 @@ The prior ships inside the package: our runs, in the shared form (no titles, pat
112
113
 
113
114
  ## The loop
114
115
 
115
- The plan and record skills take an agent through the loop in three commands:
116
+ The plan and record guides take an agent through the loop in three commands:
116
117
 
117
118
  ```sh
118
119
  loopmath recommend --type bug_fix --repo acme/api --title "Fix the parser crash" --json --brief --html
@@ -180,7 +181,7 @@ The workflow builder is the one page that is served: `loopmath builder --type bu
180
181
  | Harness testing | `check-change`, `gate` (experimental), `screen` (experimental) |
181
182
  | Task subsets | `tasks pick` (experimental) |
182
183
  | Evolution loops | `adapt openevolve` (experimental), `adapt shinkaevolve` (experimental), `recommend --role` (experimental) |
183
- | Skill | `skill` (install, uninstall, show) |
184
+ | Skill | `skill` (install, uninstall, show), `guide` |
184
185
  | OCP | `ocp` (validate, migrate) |
185
186
  | Log analysis | `analyze`, `graph`, `adapt`, `prices`, `validate-prices` |
186
187
 
@@ -1,10 +1,10 @@
1
- loopmath/__init__.py,sha256=y93j_sJ_eoVfGMIaWNTztqEsEVGVnsrthVoYchpWmaA,244
1
+ loopmath/__init__.py,sha256=FwSfUFdPCwuJZg0s1wSveMcOr9gr_X7IUxADSVkttRQ,244
2
2
  loopmath/__main__.py,sha256=X6nV3FjHmxDbIjccOYrBts_0KyJwOmDEPI5URzMO_-8,126
3
3
  loopmath/adapter_host.py,sha256=KBLHsP-LzrRDzOaDQMJRDq-NfCJeT5nY_CQAPLqyKQ4,10284
4
- loopmath/cli.py,sha256=OSVbSpZbLLO6DJ8o-PfnAH5IhHKhjmRXpWrgACLKiAE,30365
4
+ loopmath/cli.py,sha256=16RLm--_f0u9Eh9VX5-xG4l4hzgSKuwn0zDdbBTMe2I,30372
5
5
  loopmath/cli_errors.py,sha256=pf7kuCoA--zV0L4wwj8v3JA3KrJFaDIcdLUUuSF2sRo,4839
6
6
  loopmath/cli_graph.py,sha256=30VWDHnTEwAB_IX6CL_FluvnfAjydwrjDm0GRlBcLlQ,13492
7
- loopmath/cli_registry.py,sha256=lenq9xKslbxEjCUV8BAATEkxT44m-IfjNW6Stik9dt0,66916
7
+ loopmath/cli_registry.py,sha256=8mrRrjVNTt2BEbGyVgMW5toTi98R-tBYe0byRZf8UlU,67309
8
8
  loopmath/cli_support.py,sha256=gD_33ELLH4oUuYtWbxoCSYr2LUpJuh3ay80sn1KpTUA,23199
9
9
  loopmath/explain.py,sha256=fQN2ANW4fniyWdm0k14Cvioicm_Nncx7-lanVPteTUw,3166
10
10
  loopmath/fit.py,sha256=8eelfN7KqrHVQFLvWkq0iCgHLD7Jun8shuslUFuXfmU,14680
@@ -214,7 +214,7 @@ loopmath/ocp/schema/ocp-v0.2.schema.json,sha256=T4P5gg6H2dW-28MRbg9fSNct_ejXezI6
214
214
  loopmath/ocp/schema/ocp-v0.3.schema.json,sha256=uu1r4JGKc3JqBxz8m07dPrJiT64FMRZkibx048-AUug,74227
215
215
  loopmath/ocp/schema/ocp-v0.schema.json,sha256=tOGqmvAjh0Ap09zV3QLQp3PovQB8inpVNgxSnrPS354,15279
216
216
  loopmath/onboard/__init__.py,sha256=j0dutH36289ZKhbrX7P9fYGY-xbV6k9vSYmC5YIH120,126
217
- loopmath/onboard/commands.py,sha256=K5JRC6LknznH5vZqL6In_ghNy2bslyvss_hsBeiKciQ,22536
217
+ loopmath/onboard/commands.py,sha256=38KIZqR8VvtO5bhYc65B4SLDM6tHFsEUbu_y9nf24cc,22544
218
218
  loopmath/onboard/history.py,sha256=qQqidw7pg-XOSQir8bcImTfP3fdFcGt8VsnrpuRMX4A,26469
219
219
  loopmath/onboard/label.py,sha256=nKlveJNggqxKcK3I60QQF8L0y0iEcm2d-LIP0Ca3n50,19571
220
220
  loopmath/onboard/usual.py,sha256=rEyg6WOCzEN8Y-UsHLh2br218qdca3IzRp1FVaA_qgw,3444
@@ -269,16 +269,17 @@ loopmath/share/commands.py,sha256=tFVrahWyH3nYVKF3ilVQmqXfN1YRoMsn9CCtxCv8tgM,66
269
269
  loopmath/share/export.py,sha256=5UTjI9e4NCmwzceV00iKXOXS1NzbYBy7WrcVyOq5AZA,27397
270
270
  loopmath/share/import_.py,sha256=Q-Xkr6bQaPXjgRNZi1ldnStTcQfQQDvdDNrnARhdat8,18290
271
271
  loopmath/skill/__init__.py,sha256=-DtMdtjqlKOBIRA-3sdr1oiJHqkL5xLBNuvkteYCRFk,95
272
- loopmath/skill/commands.py,sha256=wfddJHUprdiM6ChgIT0IYdKZlcc96F8rQQnZbQN_z7o,4643
273
- loopmath/skill/doctor.py,sha256=Kdx7sUmlL1XWwk32ZuuWsuHyD50dme2Isrts47goei0,10776
274
- loopmath/skill/install.py,sha256=IHyXkVeRThAw7h8hmaImFr3iGia-hW4NG8tutf4f5-s,26095
275
- loopmath/skill/skills/reference.md,sha256=feqZIhyKCRDb7Cl46g73IqD_0D99aXy6frfg4Vs4UHs,16675
276
- loopmath/skill/skills/loopmath/SKILL.md,sha256=MUb_5Nu_0HwuD_pKHiQgoopxG6YLV2gj99oXT6umuAA,2473
277
- loopmath/skill/skills/loopmath-import-runs/SKILL.md,sha256=A-mSL5-a31-umQCtpHgnclHD3V1_eSKGMV1SmrxTHdE,3131
278
- loopmath/skill/skills/loopmath-onboard/SKILL.md,sha256=hQDyFW5FBgw03p6pHl3CxJIiHrQ3edbZmSwcmZMSJ0s,4814
279
- loopmath/skill/skills/loopmath-plan-task/SKILL.md,sha256=TE6UcVtRUGy3gkCKZLl05i472IGKeT14-gVb6gA_dzc,10691
280
- loopmath/skill/skills/loopmath-record-run/SKILL.md,sha256=rp6rI0fkeE5Fcng1dGKdae6q0K6R_kK8aLbHpDMWazk,6723
281
- loopmath/skill/skills/loopmath-update-fit/SKILL.md,sha256=JEO8sEm2GsBZ7IoJNOkSdAshTtBofFa0Rfy34P-0aN4,2648
272
+ loopmath/skill/commands.py,sha256=ylzGDiLHAaiewFLJbXa_FvmlHEfGdJQNZUESokDrzLg,4636
273
+ loopmath/skill/doctor.py,sha256=DS7rYXdH0E_uq1YMS_LMZXbkl6H465zS4epDBiNTvBk,12220
274
+ loopmath/skill/guide.py,sha256=CcSLpTGjGLZKu1N0IiaItZUqRiZXWVUiPQOZEibNpLo,2267
275
+ loopmath/skill/install.py,sha256=o1iPskwmfNCAXowYyknfLCFyNNEE1OqbyWn1IwnrLuo,29895
276
+ loopmath/skill/guides/fit.md,sha256=OXW_AxHXGUgR5sJ-JLdlhzAC5fEUc1pLtSaPWpw-kn8,2301
277
+ loopmath/skill/guides/import.md,sha256=iLjA3sABPeZtMwki3lCWPZgaaSFXgnFpp_LWqZRVIc0,2678
278
+ loopmath/skill/guides/onboard.md,sha256=CuN4a13hktbJssDnXXk-CQjdUAJ-h6yh87eJ8CZ-m7Q,4409
279
+ loopmath/skill/guides/plan.md,sha256=CG9V3opdsO1ejBJpwo56lz_01DmRt2rg0TJqs6sF-eQ,10086
280
+ loopmath/skill/guides/record.md,sha256=DOf0BJ-qo3AOOEtDFGuf1RYwHrq-sEezay3apUEgbKQ,6231
281
+ loopmath/skill/guides/reference.md,sha256=Fp7EMaPNjdmFkxW4ImxhkWRlOvxZ5gb4Par0pxXXjEU,16604
282
+ loopmath/skill/skills/loopmath/SKILL.md,sha256=fr2rj-2ICFAI6Vw7TtwtnWMcvcYs8QCwc-nrrW261_I,3550
282
283
  loopmath/store/__init__.py,sha256=vCGuqOSRKmKoT4eLbjEl8kxJRwdHWqxouGTp6gqPLFE,708
283
284
  loopmath/store/budget.py,sha256=5ra1EuTJOQ5K7xCaN2_cdqQWbPvRkyLjcBuD5K32PvY,8526
284
285
  loopmath/store/commands.py,sha256=28Lnw-YiXZZFy5oYMPfINMXrHAoT_Z2IeCtvFgQlfVs,81726
@@ -341,12 +342,12 @@ loopmath/workflows/catalog/plan_implement.toml,sha256=qxAs6G3JGOUuW6TnhiaUXzaFfy
341
342
  loopmath/workflows/catalog/plan_implement_review.toml,sha256=rRtiactglcJAynFWbrjnI-Ftbl3qe971ov9HJ3Vr7uU,862
342
343
  loopmath/workflows/catalog/solo.toml,sha256=aJWBEEfS4DNCLqznDI3yp-7s1ZXx_rdqsEIPX7n0-nM,373
343
344
  loopmath/workflows/catalog/swarm.toml,sha256=1hbQR41nl7VS_XN1z2fmwLCNw6kn2syowpwwauFUL3o,850
344
- loopmath-0.3.2.data/data/spec/ocp-v0.2.schema.json,sha256=T4P5gg6H2dW-28MRbg9fSNct_ejXezI69-SaKR9WogU,31855
345
- loopmath-0.3.2.data/data/spec/ocp-v0.schema.json,sha256=tOGqmvAjh0Ap09zV3QLQp3PovQB8inpVNgxSnrPS354,15279
346
- loopmath-0.3.2.data/data/spec/ocp_conformance.py,sha256=VzRGKvC6f-64U72xrDOSJEeYa92Bpj3tEf5x0uJXqhk,893
347
- loopmath-0.3.2.dist-info/licenses/LICENSE,sha256=QMvrQqRQRR-OjtyK0CiOxBV8NgWwr_QacIeFUWXeI5o,1065
348
- loopmath-0.3.2.dist-info/METADATA,sha256=dK5aKMXV7NQrWS30NNu5CGoEQ2RtrxgR3B247v4mEHc,39118
349
- loopmath-0.3.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
350
- loopmath-0.3.2.dist-info/entry_points.txt,sha256=WQwYqfGAwvoQ_vu6_lwQpq3V8xbK3i9SyNKPDdQ1VmQ,72
351
- loopmath-0.3.2.dist-info/top_level.txt,sha256=SH9Y0Z7thA0zx1PAgHAwc1vOJaS6o3yS5HazS-LzXOg,9
352
- loopmath-0.3.2.dist-info/RECORD,,
345
+ loopmath-0.3.4.data/data/spec/ocp-v0.2.schema.json,sha256=T4P5gg6H2dW-28MRbg9fSNct_ejXezI69-SaKR9WogU,31855
346
+ loopmath-0.3.4.data/data/spec/ocp-v0.schema.json,sha256=tOGqmvAjh0Ap09zV3QLQp3PovQB8inpVNgxSnrPS354,15279
347
+ loopmath-0.3.4.data/data/spec/ocp_conformance.py,sha256=VzRGKvC6f-64U72xrDOSJEeYa92Bpj3tEf5x0uJXqhk,893
348
+ loopmath-0.3.4.dist-info/licenses/LICENSE,sha256=Df5w_-_yYMWXFWcPR1Cj0pDXWBCE5_xdFN9WCNGHuGQ,1065
349
+ loopmath-0.3.4.dist-info/METADATA,sha256=rDpRaSxt3ZMOJ5UumjfA-XAbwg_3kcmbnfScKIbSbSA,39523
350
+ loopmath-0.3.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
351
+ loopmath-0.3.4.dist-info/entry_points.txt,sha256=WQwYqfGAwvoQ_vu6_lwQpq3V8xbK3i9SyNKPDdQ1VmQ,72
352
+ loopmath-0.3.4.dist-info/top_level.txt,sha256=SH9Y0Z7thA0zx1PAgHAwc1vOJaS6o3yS5HazS-LzXOg,9
353
+ loopmath-0.3.4.dist-info/RECORD,,
@@ -1,6 +1,6 @@
1
1
  MIT License
2
2
 
3
- Copyright (c) 2026 QKV Labs
3
+ Copyright (c) 2026 loopmath
4
4
 
5
5
  Permission is hereby granted, free of charge, to any person obtaining a copy
6
6
  of this software and associated documentation files (the "Software"), to deal