leos-agent 10.2.0 → 10.6.0

package/scripts/leo-install.py

@@ -23,7 +23,14 @@ import sys
 import tempfile
 from pathlib import Path
 
-HARNESSES = ("claude", "codex", "cursor", "hermes", "pi", "opencode")
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import routing  # noqa: E402  owns the harness list and the machine-local model config
+
+HARNESSES = routing.HARNESSES
+
+# The routing region inside the payload, replaced per harness at install time.
+ROUTING_OPEN = "<!-- leos-agent:routing -->"
+ROUTING_CLOSE = "<!-- /leos-agent:routing -->"
 
 OPEN_RE = re.compile(r"^<leos-agent\b[^>]*>[ \t]*$", re.MULTILINE)
 CLOSE_RE = re.compile(r"^</leos-agent>[ \t]*$", re.MULTILINE)
@@ -36,10 +43,18 @@ CODEX_SOFT_CAP = 28 * 1024
 # copies apart from a file the user happens to have put at the same path.
 PROVENANCE = "leos-agent"
 
+# Skill and command text refers to scripts as <plugin-root>/scripts/… and the
+# model resolves the root once. OpenCode copies live apart from the scripts,
+# and OpenCode sets no resolution env var, so their copies are installed with
+# the token already replaced by this machine's absolute plugin root. Installing
+# alternately from a checkout and a cache re-bakes the root each time — last
+# install wins, and --check reports a stale root as out of date.
+PLUGIN_ROOT_TOKEN = "<plugin-root>"
+
 # OpenCode plugins cannot register skills or commands from JS, so these are
 # copied to disk instead. check.py asserts every file they name carries
 # PROVENANCE, without which the installer would refuse to upgrade its own copy.
-OPENCODE_SKILLS = ("doctor", "review-pr", "handoff", "handon")
+OPENCODE_SKILLS = ("doctor", "review-pr", "handoff", "handon", "tune-routing")
 OPENCODE_COMMANDS = ("review-pr", "handoff", "handon")
 
 # Codex plugins cannot package custom agent definitions directly, so these are
@@ -100,19 +115,71 @@ def read_version(root):
 		sys.exit(f"leo-install: {manifest} has no version field")
 
 
-def payload_body(root):
-	"""The canonical payload: rules/preferences.md with its frontmatter stripped."""
+def render_routing(body, harness, config):
+	"""Replace the routing region with the stanza for this machine's config.
+
+	The payload ships with a default inside the region, so an un-rendered read of
+	rules/preferences.md -- Cursor's plugin-delivered rule, a human opening the
+	file -- still says something true. Rendering only ever narrows it to the one
+	harness being installed, which is why the installed payload is smaller than
+	the file on disk rather than larger.
+	"""
+	start = body.find(ROUTING_OPEN)
+	end = body.find(ROUTING_CLOSE)
+	if start < 0 or end < start:
+		sys.exit(f"leo-install: rules/preferences.md is missing its {ROUTING_OPEN} region")
+	return body[:start] + routing.stanza(harness, config) + body[end + len(ROUTING_CLOSE):]
+
+
+def payload_body(root, harness=None, config=None):
+	"""The canonical payload: rules/preferences.md with its frontmatter stripped.
+
+	With a harness, the routing region is rendered for it; without one the region
+	keeps its shipped default, markers and all.
+	"""
 	text = (root / "rules" / "preferences.md").read_text(encoding="utf-8")
 	body = re.sub(r"(?s)\A---\n.*?\n---\n", "", text, count=1).strip()
 	if not body:
 		sys.exit("leo-install: rules/preferences.md has no body below its frontmatter")
 	if OPEN_RE.search(body) or CLOSE_RE.search(body):
 		sys.exit("leo-install: rules/preferences.md contains a <leos-agent> marker; it must not")
+	if harness:
+		body = render_routing(body, harness, config if config is not None else routing.load())
 	return body
 
 
-def build_block(root):
-	return f'<leos-agent version="{read_version(root)}">\n{payload_body(root)}\n</leos-agent>\n'
+def build_block(root, harness=None, config=None):
+	return f'<leos-agent version="{read_version(root)}">\n{payload_body(root, harness, config)}\n</leos-agent>\n'
+
+
+def render_codex_agent(text, agent_name, config):
+	"""Substitute a Codex profile's model, leaving the shipped default when unset."""
+	entry = routing.profile(config, "codex", agent_name.split("-", 1)[1])
+	if not entry:
+		return text
+	text = re.sub(r'(?m)^model = ".*"$', f'model = "{entry["model"]}"', text, count=1)
+	if entry["effort"]:
+		text = re.sub(
+			r'(?m)^model_reasoning_effort = ".*"$',
+			f'model_reasoning_effort = "{entry["effort"]}"',
+			text,
+			count=1,
+		)
+	return text
+
+
+def cursor_routing_rule(harness, config):
+	"""Cursor reads its rules straight out of the plugin, so the per-machine half
+	has to arrive as its own always-applied rule file."""
+	return (
+		"---\n"
+		"description: leos-agent model routing for this machine.\n"
+		"alwaysApply: true\n"
+		"---\n"
+		"This supersedes the model-routing dispatch line in Leo's agent operating\n"
+		"preferences:\n\n"
+		f"{routing.stanza(harness, config)}\n"
+	)
 
 
 def scan_markers(text):
@@ -124,16 +191,19 @@ def scan_markers(text):
 	into a permanent "two blocks" error, so fenced regions are skipped.
 	"""
 	opens, closes = [], []
-	fence = None
+	fence = None  # (char, run length) of the currently open fence
 	offset = 0
 	for line in text.splitlines(keepends=True):
 		stripped = line.lstrip()
-		marker = stripped[:3]
-		if marker in ("```", "~~~"):
-			token = marker
+		run = re.match(r"(`{3,}|~{3,})", stripped)
+		if run:
+			token = run.group(1)
 			if fence is None:
-				fence = token
-			elif fence == token:
+				fence = (token[0], len(token))
+			# CommonMark: only a run of the same character at least as long as
+			# the opener closes a fence; a shorter run is fence content, so a
+			# ``` line inside a ```` example must not end the example.
+			elif fence[0] == token[0] and len(token) >= fence[1]:
 				fence = None
 		elif fence is None:
 			if OPEN_RE.match(line.rstrip("\n")):
@@ -283,11 +353,16 @@ def install_markdown(path, block, args, label, create=True):
 	return write_if_changed(path, inject(current, block), current, existed, crlf, args, label)
 
 
-def install_file_copy(src, dest, args, label, owned_parent=False):
-	"""Install a payload file the harness's plugin system cannot deliver itself."""
+def install_file_copy(src, dest, args, label, owned_parent=False, payload=None):
+	"""Install a payload file the harness's plugin system cannot deliver itself.
+
+	`payload` overrides the source text for files rendered from the machine's
+	routing config rather than copied verbatim.
+	"""
 	dest = dest.expanduser()
 	existed = dest.is_file()
-	payload = src.read_text(encoding="utf-8")
+	if payload is None:
+		payload = src.read_text(encoding="utf-8")
 	current = dest.read_text(encoding="utf-8") if existed else ""
 
 	# Never clobber or delete a same-named file this tool did not put there.
@@ -307,8 +382,27 @@ def install_file_copy(src, dest, args, label, owned_parent=False):
 	return write_if_changed(dest, payload, current, existed, False, args, label)
 
 
+def opencode_payload(src, root, rename_install=False):
+	"""An OpenCode copy's content: the plugin root baked in, optionally renamed.
+
+	OpenCode reads the copies out of ~/.config/opencode, far from the scripts
+	they invoke, and sets none of the resolution env vars — so the placeholder
+	is resolved here, at install time, where the root is known for certain.
+	The install skill is additionally renamed to match the leo-install/
+	directory it is copied into, keeping directory and frontmatter in
+	agreement whichever one OpenCode keys on.
+	"""
+	text = src.read_text(encoding="utf-8").replace(PLUGIN_ROOT_TOKEN, str(root))
+	if rename_install:
+		text = re.sub(r"(?m)^name:\s*install\s*$", "name: leo-install", text, count=1)
+	return text
+
+
 def run(harness, root, args):
-	block = build_block(root)
+	# Read once per run: rendering has to be a pure function of (version, config)
+	# or a second install would not come back "unchanged".
+	config = routing.load()
+	block = build_block(root, harness, config)
 	home = Path.home()
 	targets = []
 
@@ -328,22 +422,43 @@ def run(harness, root, args):
 						home / ".codex" / "agents" / f"{n}.toml",
 						args,
 						l,
+						payload=render_codex_agent(
+							(root / "payload" / "codex-agents" / f"{n}.toml").read_text(encoding="utf-8"),
+							n,
+							config,
+						),
 					),
 				)
 			)
 
 	elif harness == "cursor":
-		targets.append(
-			(
-				"cursor",
-				lambda: Result(
-					"cursor",
-					"skipped",
-					"Cursor has no on-disk global rules file; the plugin's alwaysApply rule delivers the payload natively",
-				),
-			)
+		# The payload itself arrives natively through the plugin's alwaysApply
+		# rule, which is the file in the plugin directory -- so there is nothing
+		# per-machine in it. Only the routing stanza needs installing, and only
+		# as its own rule -- and only when something is actually configured: an
+		# unconfigured rule would restate the payload's default, an always-loaded
+		# no-op that costs context on every turn.
+		label = "~/.cursor/rules/leos-agent-routing.mdc"
+		dest = home / ".cursor" / "rules" / "leos-agent-routing.mdc"
+		configured = bool(
+			routing.profile(config, "cursor", "runner") or routing.profile(config, "cursor", "executor")
 		)
 
+		def cursor_rule_target(l=label):
+			if args.uninstall or configured:
+				return install_file_copy(None, dest, args, l, payload=cursor_routing_rule(harness, config))
+			# Unconfigured install: write nothing, and take back a stale rule a
+			# previous config left behind -- but only one that is provably ours.
+			if not dest.is_file():
+				return Result(l, "skipped", "no routing configured for cursor")
+			if PROVENANCE not in dest.read_text(encoding="utf-8"):
+				return Result(l, "skipped", "no routing configured; leaving the unrelated file at this path")
+			if args.writes:
+				dest.unlink()
+			return Result(l, "removed", "no routing configured; stale rule removed")
+
+		targets.append((label, cursor_rule_target))
+
 	elif harness == "hermes":
 		# Never create SOUL.md: Hermes writes its own starter identity file on
 		# first run, and pre-empting that would fight the bootstrap.
@@ -374,6 +489,9 @@ def run(harness, root, args):
 					args,
 					skill_label,
 					owned_parent=True,
+					payload=opencode_payload(
+						root / "skills" / "install" / "SKILL.md", root, rename_install=True
+					),
 				),
 			)
 		)
@@ -394,6 +512,7 @@ def run(harness, root, args):
 							args,
 							l,
 							owned_parent=True,
+							payload=opencode_payload(s, root),
 						),
 					)
 				)
@@ -407,6 +526,7 @@ def run(harness, root, args):
 						args,
 						l,
 						owned_parent=True,
+						payload=opencode_payload(root / "skills" / n / "SKILL.md", root),
 					),
 				)
 			)
@@ -420,6 +540,7 @@ def run(harness, root, args):
 						cfg / "commands" / f"{n}.md",
 						args,
 						l,
+						payload=opencode_payload(root / "commands" / f"{n}.md", root),
 					),
 				)
 			)

package/scripts/measure_context.py

@@ -8,6 +8,7 @@ regressions remain visible without a tokenizer or network access.
 """
 
 import argparse
+import importlib.util
 import json
 import re
 import sys
@@ -19,9 +20,19 @@ ROOT = Path(__file__).resolve().parent.parent
 # the before/after output in the change that raises it.
 LIMITS = {
 	"global_policy_bytes": 4_500,
+	# What an unconfigured machine actually installs. Rendering the routing region
+	# per harness dropped this below the old whole-file figure of 4497, and it must
+	# stay there: the model config exists to save money, so it may not cost
+	# always-loaded bytes to have. A configured harness exceeds this only by the
+	# length of the model names chosen, which is bounded and deliberate.
+	"rendered_policy_bytes": 4_497,
 	"codex_implicit_skill_metadata_bytes": 600,
 	"claude_implicit_skill_metadata_bytes": 800,
 	"codex_agent_description_bytes": 550,
+	"claude_agent_description_bytes": 550,
+	# Command descriptions are listed alongside skills in Claude Code and Cursor,
+	# so they are always-loaded context on the same terms as skill metadata.
+	"command_description_bytes": 400,
 	"review_dispatch_bytes": 3_500,
 }
 
@@ -69,6 +80,20 @@ def agent_description(path):
 	return match.group(1)
 
 
+def rendered_policy():
+	"""The installed payload body per harness, with no routing config present.
+
+	This is what a session actually loads -- rules/preferences.md on disk keeps a
+	harness-neutral default in its routing region, and the installer narrows it to
+	one harness. Measured with the config forced empty so the number is a property
+	of the repository, not of whoever runs it.
+	"""
+	spec = importlib.util.spec_from_file_location("leo_install_measure", ROOT / "scripts" / "leo-install.py")
+	installer = importlib.util.module_from_spec(spec)
+	spec.loader.exec_module(installer)
+	return {h: byte_len(installer.payload_body(ROOT, h, {})) for h in installer.HARNESSES}
+
+
 def measurements():
 	portable = sorted((ROOT / "skills").glob("*/SKILL.md"))
 	claude_only = sorted((ROOT / "skills-claude").glob("*/SKILL.md"))
@@ -77,11 +102,26 @@ def measurements():
 	review_fm, review_body = frontmatter(ROOT / "skills" / "review-pr" / "SKILL.md")
 	del review_fm
 	agent_paths = sorted((ROOT / "payload" / "codex-agents").glob("*.toml"))
+	# Claude Code lists every plugin agent's name and description in the parent's
+	# always-loaded agent roster, so they are part of the static footprint too.
+	claude_agent_paths = sorted((ROOT / "agents").glob("*.md"))
+	claude_agent_bytes = 0
+	for path in claude_agent_paths:
+		fm, _ = frontmatter(path)
+		claude_agent_bytes += byte_len(field(fm, "name")) + byte_len(field(fm, "description"))
+	command_paths = sorted((ROOT / "commands").glob("*.md")) + sorted((ROOT / "commands-claude").glob("*.md"))
+	command_bytes = 0
+	for path in command_paths:
+		fm, _ = frontmatter(path)
+		command_bytes += byte_len(field(fm, "description"))
 	return {
 		"global_policy_bytes": byte_len(policy_body.strip()),
+		"rendered_policy_bytes": max(rendered_policy().values()),
 		"codex_implicit_skill_metadata_bytes": skill_metadata_bytes(portable, codex_implicit),
 		"claude_implicit_skill_metadata_bytes": skill_metadata_bytes(portable + claude_only, claude_implicit),
 		"codex_agent_description_bytes": sum(byte_len(agent_description(path)) for path in agent_paths),
+		"claude_agent_description_bytes": claude_agent_bytes,
+		"command_description_bytes": command_bytes,
 		"review_dispatch_bytes": byte_len(review_body.strip()),
 	}
 
@@ -99,6 +139,9 @@ def main(argv=None):
 		print("Static prompt footprint (bytes; tokens are roughly bytes / 4 for this prose)")
 		for name, value in values.items():
 			print(f"  {name:38} {value:5}  limit {LIMITS[name]:5}")
+		print("  rendered_policy_bytes is the worst case across harnesses; each one installs:")
+		for harness, value in sorted(rendered_policy().items()):
+			print(f"    {harness:38} {value:5}")
 		print("This excludes conversation history, tool output, cache effects, and subagent work.")
 
 	over = {name: (value, LIMITS[name]) for name, value in values.items() if value > LIMITS[name]}