unharness 3.6.0__tar.gz

unharness-3.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arthur Ryzhak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

unharness-3.6.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: unharness
+Version: 3.6.0
+Summary: Compile a manifesto stack into a session's system prompt and launch Claude Code with it.
+Keywords: claude-code,system-prompt,manifesto
+Author: Arthur Ryzhak
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/ryzhakar/llm-manifestos
+Project-URL: Repository, https://github.com/ryzhakar/llm-manifestos
+Project-URL: Documentation, https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/unharness/README.md
+Description-Content-Type: text/markdown
+
+# unharness
+
+Compile a project's manifesto stack into a Claude Code session's system prompt, and launch the session with the harness's own instructions switched off.
+
+```
+/compile-commitments
+uvx unharness prompt | uvx unharness launch -- claude
+```
+
+To run the source at the v3.6.0 tag instead, use `uvx --from "git+https://github.com/ryzhakar/llm-manifestos@v3.6.0#subdirectory=plugin/unharness" unharness` in place of `uvx unharness`. The launcher's input is reopened on the terminal.
+
+- `unharness prompt [--config PATH] [--digests] [--stack-digests] [--overlap] [--minified]` prints the compiled prompt. `--digests` and `--stack-digests` swap manifesto texts for digests, `--overlap` lets stack digests share a manifesto, and `--minified` loads the min pair, the two `.min.md` session files; the Unharness section of [`plugin/README.md`](https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/README.md) states the cover rule.
+- `unharness stack [--config PATH] [SLUG ...]` prints the `<stack>` block and the constitution; given slugs, it prints those manifestos alone.
+- `unharness stamp DIGEST [--config PATH]` writes the digest's entry into its `index.json`, as in `unharness stamp .claude/digests/dry.md`.
+- `unharness doctor [--config PATH] [--digests] [--stack-digests] [--overlap] [--minified]` prints one `OK`, `WARN`, or `FAIL` line per check and exits 1 on any FAIL.
+- `unharness launch [--keep-claude-md] [--keep-web-search] [--no-hooks] [PROMPT] [-- LAUNCHER [ARGS...]]` caches the prompt and runs the launcher, or prints the command when none follows `--`.
+
+The config schema is in [`plugin/SCHEMA.md`](https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/SCHEMA.md). The strip table and the text that stays are in the Unharness section of [`plugin/README.md`](https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/README.md).
+
+Test with `uv run --project plugin/unharness pytest -q` from the repository root.

unharness-3.6.0/README.md

@@ -0,0 +1,20 @@
+# unharness
+
+Compile a project's manifesto stack into a Claude Code session's system prompt, and launch the session with the harness's own instructions switched off.
+
+```
+/compile-commitments
+uvx unharness prompt | uvx unharness launch -- claude
+```
+
+To run the source at the v3.6.0 tag instead, use `uvx --from "git+https://github.com/ryzhakar/llm-manifestos@v3.6.0#subdirectory=plugin/unharness" unharness` in place of `uvx unharness`. The launcher's input is reopened on the terminal.
+
+- `unharness prompt [--config PATH] [--digests] [--stack-digests] [--overlap] [--minified]` prints the compiled prompt. `--digests` and `--stack-digests` swap manifesto texts for digests, `--overlap` lets stack digests share a manifesto, and `--minified` loads the min pair, the two `.min.md` session files; the Unharness section of [`plugin/README.md`](https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/README.md) states the cover rule.
+- `unharness stack [--config PATH] [SLUG ...]` prints the `<stack>` block and the constitution; given slugs, it prints those manifestos alone.
+- `unharness stamp DIGEST [--config PATH]` writes the digest's entry into its `index.json`, as in `unharness stamp .claude/digests/dry.md`.
+- `unharness doctor [--config PATH] [--digests] [--stack-digests] [--overlap] [--minified]` prints one `OK`, `WARN`, or `FAIL` line per check and exits 1 on any FAIL.
+- `unharness launch [--keep-claude-md] [--keep-web-search] [--no-hooks] [PROMPT] [-- LAUNCHER [ARGS...]]` caches the prompt and runs the launcher, or prints the command when none follows `--`.
+
+The config schema is in [`plugin/SCHEMA.md`](https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/SCHEMA.md). The strip table and the text that stays are in the Unharness section of [`plugin/README.md`](https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/README.md).
+
+Test with `uv run --project plugin/unharness pytest -q` from the repository root.

unharness-3.6.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "unharness"
+version = "3.6.0"
+description = "Compile a manifesto stack into a session's system prompt and launch Claude Code with it."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "claude-code",
+    "system-prompt",
+    "manifesto",
+]
+classifiers = [
+    "Environment :: Console",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+requires-python = ">=3.11"
+dependencies = []
+
+[[project.authors]]
+name = "Arthur Ryzhak"
+
+[project.urls]
+Homepage = "https://github.com/ryzhakar/llm-manifestos"
+Repository = "https://github.com/ryzhakar/llm-manifestos"
+Documentation = "https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/unharness/README.md"
+
+[project.scripts]
+unharness = "unharness.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.12.23,<0.13"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["pytest>=8"]

unharness-3.6.0/pyproject.toml.orig

@@ -0,0 +1,32 @@
+[project]
+name = "unharness"
+version = "3.6.0"
+description = "Compile a manifesto stack into a session's system prompt and launch Claude Code with it."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Arthur Ryzhak" }]
+keywords = ["claude-code", "system-prompt", "manifesto"]
+classifiers = [
+    "Environment :: Console",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+requires-python = ">=3.11"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/ryzhakar/llm-manifestos"
+Repository = "https://github.com/ryzhakar/llm-manifestos"
+Documentation = "https://github.com/ryzhakar/llm-manifestos/blob/v3.6.0/plugin/unharness/README.md"
+
+[project.scripts]
+unharness = "unharness.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.12.23,<0.13"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["pytest>=8"]

unharness-3.6.0/src/unharness/cli.py

@@ -0,0 +1,115 @@
+"""The unharness command: print the compiled prompt, print the stack a session binds to, or launch a session."""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from unharness.compile import FULL_FILES, MINIFIED_FILES, compile_prompt, stack_view
+from unharness.config import EMPTY_STACK_MESSAGE, UnharnessError, fail, load
+from unharness.digests import DIGESTS_FLAG, OVERLAP_FLAG, STACK_DIGESTS_FLAG, constitution_blocks, digest_mode, stamp_digest
+from unharness.doctor import Modes, claude_version, doctor, has_failed
+from unharness.launch import Options, cache_home, execute_launcher, launch, reopen_terminal, terminal_device
+from unharness.resolve import login_dir, manifesto_elements, manifesto_plugin_dir, resolve_stack
+from unharness.session import load_preamble, read_if_present
+
+DEFAULT_CONFIG = Path(".manifestos.yaml")
+PROMPT_VERB = "prompt"
+STACK_VERB = "stack"
+STAMP_VERB = "stamp"
+LAUNCH_VERB = "launch"
+DOCTOR_VERB = "doctor"
+MINIFIED_FLAG = "--minified"
+MODE_FLAGS = (DIGESTS_FLAG, STACK_DIGESTS_FLAG, OVERLAP_FLAG, MINIFIED_FLAG)
+LAUNCHER_SEPARATOR = "--"
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the verb named in argv; print its output, or fail in one line with exit status 1."""
+    argv = sys.argv[1:] if argv is None else argv
+    argv, launcher = _split_launcher(argv)
+    parser = argparse.ArgumentParser(prog="unharness")
+    verbs = parser.add_subparsers(dest="verb", required=True)
+    prompt_parser = verbs.add_parser(PROMPT_VERB)
+    stack_parser = verbs.add_parser(STACK_VERB)
+    stack_parser.add_argument("slugs", nargs="*")
+    for parser_of_verb in (prompt_parser, stack_parser):
+        parser_of_verb.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
+    for flag in MODE_FLAGS:
+        prompt_parser.add_argument(flag, action="store_true")
+    stamp_parser = verbs.add_parser(STAMP_VERB)
+    stamp_parser.add_argument("digest", type=Path)
+    stamp_parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
+    launch_parser = verbs.add_parser(LAUNCH_VERB)
+    launch_parser.add_argument("prompt", nargs="?")
+    for flag in ("--keep-claude-md", "--keep-web-search", "--no-hooks"):
+        launch_parser.add_argument(flag, action="store_true")
+    doctor_parser = verbs.add_parser(DOCTOR_VERB)
+    doctor_parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
+    for flag in MODE_FLAGS:
+        doctor_parser.add_argument(flag, action="store_true")
+    arguments = parser.parse_args(argv)
+    try:
+        if arguments.verb == LAUNCH_VERB:
+            return _launch(arguments, launcher)
+        if arguments.verb == DOCTOR_VERB:
+            return _doctor(arguments)
+        login = login_dir(os.environ, Path.home())
+        print(_stamp(arguments, login) if arguments.verb == STAMP_VERB else _output(arguments, login))
+    except UnharnessError as error:
+        return fail(error)
+    return 0
+
+
+def _split_launcher(argv: list[str]) -> tuple[list[str], list[str]]:
+    """Split a launch command line at its first --, into the verb's own arguments and the launcher with its arguments."""
+    if argv[:1] != [LAUNCH_VERB] or LAUNCHER_SEPARATOR not in argv:
+        return argv, []
+    separator = argv.index(LAUNCHER_SEPARATOR)
+    return argv[:separator], argv[separator + 1:]
+
+
+def _launch(arguments: argparse.Namespace, launcher: list[str]) -> int:
+    if arguments.prompt is None and sys.stdin.isatty():
+        raise UnharnessError("no prompt: pass PROMPT or pipe unharness prompt")
+    prompt = arguments.prompt if arguments.prompt is not None else sys.stdin.read()
+    options = Options(arguments.keep_claude_md, arguments.keep_web_search, arguments.no_hooks, launcher)
+    return launch(prompt, options, os.environ, cache_home(os.environ, Path.home()), terminal_device(), reopen_terminal, execute_launcher)
+
+
+def _stamp(arguments: argparse.Namespace, login: Path) -> str:
+    index = stamp_digest(arguments.digest, load(arguments.config).registry, login)
+    return f"stamped {arguments.digest.stem} in {index}"
+
+
+def _doctor(arguments: argparse.Namespace) -> int:
+    modes = Modes(arguments.digests, arguments.stack_digests, arguments.overlap, arguments.minified)
+    findings = doctor(arguments.config, modes, login_dir(os.environ, Path.home()), os.environ, claude_version)
+    print("\n".join(finding.line for finding in findings))
+    return 1 if has_failed(findings) else 0
+
+
+def _output(arguments: argparse.Namespace, login: Path) -> str:
+    verb = arguments.verb
+    mode = digest_mode(arguments.digests, arguments.stack_digests, arguments.overlap) if verb == PROMPT_VERB else None
+    config = load(arguments.config)
+    if verb == STACK_VERB and arguments.slugs:
+        return stack_view(resolve_stack(manifesto_elements(arguments.slugs), config.directory, config.registry, login))
+    if not config.you:
+        raise UnharnessError(EMPTY_STACK_MESSAGE)
+    documents = resolve_stack(config.you, config.directory, config.registry, login)
+    if verb == STACK_VERB:
+        return stack_view(documents)
+    session_files = MINIFIED_FILES if arguments.minified else FULL_FILES
+    return compile_prompt(
+        documents,
+        load_preamble(config.directory).text,
+        read_if_present(config.directory / session_files.interplay),
+        read_if_present(config.directory / session_files.commitments),
+        constitution_blocks(config.you, documents, config.directory, manifesto_plugin_dir(config.registry, login), mode),
+        session_files,
+    )
+
+
+if __name__ == "__main__":
+    sys.exit(main())

unharness-3.6.0/src/unharness/compile.py

@@ -0,0 +1,103 @@
+"""Compile resolved documents and the session's own files into the system prompt."""
+
+import re
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from unharness.config import UnharnessError
+from unharness.resolve import Document
+
+STACK_BLOCK = re.compile(r"\A<stack>\n(.*?)\n</stack>\n*", re.S)
+INTERPLAY_FILE = ".manifestos.interplay.md"
+COMMITMENTS_FILE = ".manifestos.commitments.md"
+MINIFIED_INTERPLAY_FILE = ".manifestos.interplay.min.md"
+MINIFIED_COMMITMENTS_FILE = ".manifestos.commitments.min.md"
+DOUBLE_QUOTE = '"'
+SINGLE_QUOTE = "'"
+WRITING_SKILL = "/compile-commitments"
+
+
+@dataclass(frozen=True)
+class Block:
+    name: str
+    purpose: str | None
+    text: str
+
+
+@dataclass(frozen=True)
+class SessionFiles:
+    interplay: str
+    commitments: str
+
+
+FULL_FILES = SessionFiles(INTERPLAY_FILE, COMMITMENTS_FILE)
+MINIFIED_FILES = SessionFiles(MINIFIED_INTERPLAY_FILE, MINIFIED_COMMITMENTS_FILE)
+
+
+def compile_prompt(
+    documents: list[Document], preamble: str, interplay: str | None, commitments: str | None,
+    constitution: Sequence[Block | Document] | None = None, files: SessionFiles = FULL_FILES,
+) -> str:
+    """Return the system prompt: preamble, constitution, interplay, commitments; stop if a session file is stale."""
+    session_files = [
+        _current_body(files.interplay, interplay, documents),
+        _current_body(files.commitments, commitments, documents),
+    ]
+    return "\n\n".join([harness_block(preamble), constitution_block(documents if constitution is None else constitution), *session_files])
+
+
+def harness_block(preamble: str) -> str:
+    """Return the preamble in its tags, the first block of the system prompt."""
+    return f"<harness>\n{preamble.strip()}\n</harness>"
+
+
+def stack_view(documents: list[Document]) -> str:
+    """Return the stack block, then the constitution: what a session binds to."""
+    return f"{stack_block(documents)}\n\n{constitution_block(documents)}"
+
+
+def stack_block(documents: list[Document]) -> str:
+    """Return the stack block: one line per document, in order."""
+    return "<stack>\n" + "\n".join(_stack_lines(documents)) + "\n</stack>"
+
+
+def constitution_block(blocks: Sequence[Block | Document]) -> str:
+    """Return the constitution block: one tagged text per block, in order."""
+    return "<constitution>\n" + "\n".join(_tagged(block) for block in blocks) + "\n</constitution>"
+
+
+def _stack_lines(documents: list[Document]) -> list[str]:
+    return [f"{document.name} {document.sha256} {document.purpose or ''}".rstrip() for document in documents]
+
+
+def _tagged(block: Block | Document) -> str:
+    governs = f' governs="{block.purpose.replace(DOUBLE_QUOTE, SINGLE_QUOTE)}"' if block.purpose else ""
+    return f"<{block.name}{governs}>\n{block.text}\n</{block.name}>"
+
+
+def _current_body(file_name: str, text: str | None, documents: list[Document]) -> str:
+    """Return the session file without its stack block, or stop if the file is missing or stale."""
+    if text is None:
+        raise UnharnessError(f"{file_name} is missing; run {WRITING_SKILL}")
+    recorded = STACK_BLOCK.match(text)
+    if not recorded:
+        raise UnharnessError(f"{file_name} has no <stack> block; run {WRITING_SKILL}")
+    current_lines = _stack_lines(documents)
+    recorded_lines = recorded.group(1).split("\n")
+    if recorded_lines != current_lines:
+        raise UnharnessError(f"{file_name} is stale ({_difference(recorded_lines, current_lines)}); run {WRITING_SKILL}")
+    return text[recorded.end():].strip()
+
+
+def _difference(recorded_lines: list[str], current_lines: list[str]) -> str:
+    changed = sorted({line.split(" ")[0] for line in set(recorded_lines) ^ set(current_lines)})
+    return f"changed: {', '.join(changed)}" if changed else "reordered"
+
+
+def session_file_problem(file_name: str, text: str | None, documents: list[Document]) -> str | None:
+    """Return why the session file would stop the prompt, None when it is current."""
+    try:
+        _current_body(file_name, text, documents)
+    except UnharnessError as error:
+        return str(error)
+    return None

unharness-3.6.0/src/unharness/config.py

@@ -0,0 +1,226 @@
+"""Read a project's .manifestos.yaml into a Config, with the YAML subset reader the file needs."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+TEXT_ENCODING = "utf-8"
+LIST_MARKER = "- "
+MANIFESTO_SOURCE = "manifesto"
+SKILL_SOURCE = "skill"
+FILE_SOURCE = "file"
+CLAUDE_MD = "CLAUDE.md"
+EMPTY_STACK_MESSAGE = "the stack is empty"
+ACTIVE_MANIFESTOS_SECTION = re.compile(r"^## Active Manifestos\n(.*?)(?=^## |\Z)", re.M | re.S)
+SOURCE = re.compile(rf"^({MANIFESTO_SOURCE}|{SKILL_SOURCE}|{FILE_SOURCE}) (\S.*)$")
+MISSING_CONFIG_STATUS = 2
+MAPPING_ENTRY = re.compile(r":(?:\s|$)")
+WHITESPACE = re.compile(r"\s")
+TAB_INDENT = re.compile(r" *\t")
+YAML_NULLS = ("", "~", "null")
+QUOTED_SCALAR = re.compile(r"""^(["'])(.*?)\1(?:\s+#.*)?$""")
+TRAILING_COMMENT = re.compile(r"(?:^|\s+)#.*$")
+
+
+class UnharnessError(Exception):
+    """A failure whose one-line message tells the owner what to fix."""
+
+
+class MissingConfigError(UnharnessError):
+    """No config file and no CLAUDE.md section: a project that does not use manifestos."""
+
+
+@dataclass(frozen=True)
+class Element:
+    name: str
+    purpose: str | None
+    source_type: str | None
+    reference: str | None
+
+
+@dataclass(frozen=True)
+class Config:
+    you: list[Element]
+    subagents: dict[str, list[Element]]
+    directory: Path
+    registry: Path | None
+
+
+def fail(error: UnharnessError, status: int = 1) -> int:
+    """Print the failure as one line on stderr and return the exit status."""
+    print(f"unharness: {error}", file=sys.stderr)
+    return status
+
+
+def main(argv: list[str]) -> int:
+    """Print the config at argv's path as JSON for a shell hook; fail in one line, with status 2 when no config exists."""
+    parser = argparse.ArgumentParser(description="Print a .manifestos.yaml as JSON.")
+    parser.add_argument("path", type=Path)
+    parser.add_argument("--json", action="store_true", required=True)
+    try:
+        config = load(parser.parse_args(argv).path)
+    except MissingConfigError as error:
+        return fail(error, MISSING_CONFIG_STATUS)
+    except UnharnessError as error:
+        return fail(error)
+    print(json.dumps({
+        "you": [asdict(element) for element in config.you],
+        "subagents": {role: [asdict(element) for element in elements] for role, elements in config.subagents.items()},
+        "directory": str(config.directory),
+        "registry": str(config.registry) if config.registry else "",
+    }))
+    return 0
+
+
+def load(path: Path) -> Config:
+    """Read the config file at path into a Config."""
+    root = parse_yaml(_config_text(path))
+    if isinstance(root, list):
+        root = {"you": root}
+    root = root or {}
+    roles = root.get("subagents") or {}
+    if not isinstance(roles, dict):
+        raise UnharnessError("subagents must be a mapping of role to list of elements")
+    return Config(
+        you=_elements(root.get("you") or [], "you"),
+        subagents={role: _elements(items or [], f"subagents.{role}") for role, items in roles.items()},
+        directory=path.parent,
+        registry=(path.parent / root["manifesto_dir"]).resolve() if root.get("manifesto_dir") else None,
+    )
+
+
+def _config_text(path: Path) -> str:
+    if path.is_file():
+        return path.read_text(encoding=TEXT_ENCODING)
+    claude_md = path.parent / CLAUDE_MD
+    section = ACTIVE_MANIFESTOS_SECTION.search(claude_md.read_text(encoding=TEXT_ENCODING)) if claude_md.is_file() else None
+    if not section:
+        raise MissingConfigError(f"no config: tried {path} and the Active Manifestos section of {claude_md}")
+    return section.group(1)
+
+
+def _elements(items: list, list_label: str) -> list[Element]:
+    if not isinstance(items, list):
+        raise UnharnessError(f"{list_label} must be a list of elements")
+    present = [item for item in items if item is not None]
+    return [_element(item, f"element {number} of {list_label}") for number, item in enumerate(present, 1)]
+
+
+def _element(item: str | dict, label: str) -> Element:
+    fields = item if isinstance(item, dict) else {"name": item}
+    source_type, reference = _source(fields.get("source"), label)
+    name = fields.get("name") or (Path(reference).stem if source_type == FILE_SOURCE else None)
+    if not name:
+        raise UnharnessError(f"{label} has no name; add name: or a file source")
+    if WHITESPACE.search(name):
+        raise UnharnessError(f"{label} name {name!r} must hold no whitespace; add name:")
+    return Element(name, fields.get("purpose"), source_type, reference)
+
+
+def _source(source: str | None, label: str) -> tuple[str | None, str | None]:
+    """Split a source into its type and reference; a missing source is a registry manifesto, named by the element."""
+    if source is None:
+        return None, None
+    parsed = SOURCE.match(source)
+    if not parsed:
+        raise UnharnessError(
+            f"{label} has source {source!r} that is none of {MANIFESTO_SOURCE} <name>, "
+            f"{SKILL_SOURCE} <plugin>:<skill>, {SKILL_SOURCE} <skill>, or {FILE_SOURCE} <path>; "
+            f"write a path as {FILE_SOURCE} <path>"
+        )
+    return parsed.group(1), parsed.group(2)
+
+
+def parse_yaml(text: str):
+    """Return the structure of block-style YAML text: mappings, lists, and string scalars; None if empty."""
+    lines = [line.rstrip() for line in text.split("\n") if line.strip() and not line.lstrip().startswith("#")]
+    if not lines:
+        return None
+    for line in lines:
+        if TAB_INDENT.match(line):
+            raise UnharnessError(f"the line {line.strip()!r} is indented with a tab; indent with spaces")
+    value, consumed = _parse_block(lines, 0, _indent(lines[0]))
+    _require_consumed(lines, consumed)
+    return value
+
+
+def _require_consumed(lines: list[str], consumed: int) -> None:
+    if consumed < len(lines):
+        raise UnharnessError(f"cannot place the line {lines[consumed].strip()!r}; check its indent")
+
+
+def _indent(line: str) -> int:
+    return len(line) - len(line.lstrip(" "))
+
+
+def _scalar(text: str) -> str | None:
+    text = text.strip()
+    quoted = QUOTED_SCALAR.match(text)
+    if quoted:
+        return quoted.group(2)
+    text = TRAILING_COMMENT.sub("", text)
+    return None if text in YAML_NULLS else text
+
+
+def _split_entry(text: str) -> tuple[str, str]:
+    entry = MAPPING_ENTRY.search(text)
+    return (text[:entry.start()], text[entry.end():]) if entry else (text, "")
+
+
+def _is_item(line: str) -> bool:
+    stripped = line.lstrip()
+    return stripped == LIST_MARKER.strip() or stripped.startswith(LIST_MARKER)
+
+
+def _parse_block(lines: list[str], i: int, indent: int):
+    if _is_item(lines[i]):
+        return _parse_list(lines, i, indent)
+    return _parse_mapping(lines, i, indent)
+
+
+def _parse_list(lines: list[str], i: int, indent: int):
+    result = []
+    item_indent = indent + len(LIST_MARKER)
+    while i < len(lines) and _indent(lines[i]) == indent and _is_item(lines[i]):
+        content = lines[i].lstrip()[len(LIST_MARKER):]
+        if not MAPPING_ENTRY.search(content):
+            result.append(_scalar(content))
+            i += 1
+            continue
+        block = [" " * item_indent + content]
+        i += 1
+        while i < len(lines) and _indent(lines[i]) >= item_indent:
+            block.append(lines[i])
+            i += 1
+        value, consumed = _parse_block(block, 0, item_indent)
+        _require_consumed(block, consumed)
+        result.append(value)
+    return result, i
+
+
+def _parse_mapping(lines: list[str], i: int, indent: int):
+    result = {}
+    while i < len(lines) and _indent(lines[i]) == indent and not _is_item(lines[i]):
+        key, rest = _split_entry(lines[i].lstrip())
+        key = _scalar(key)
+        if key in result:
+            raise UnharnessError(f"key {key!r} appears twice")
+        value = _scalar(rest)
+        if value is not None:
+            result[key] = value
+            i += 1
+        elif i + 1 < len(lines) and _indent(lines[i + 1]) > indent:
+            result[key], i = _parse_block(lines, i + 1, _indent(lines[i + 1]))
+        else:
+            result[key] = None
+            i += 1
+    return result, i
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))