xrefkit 0.7.2__tar.gz → 0.7.3__tar.gz

{xrefkit-0.7.2/xrefkit.egg-info → xrefkit-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xrefkit
-Version: 0.7.2
+Version: 0.7.3
 Summary: Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit
 Author: synthaicode
 License: MIT License

{xrefkit-0.7.2 → xrefkit-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xrefkit"
-version = "0.7.2"
+version = "0.7.3"
 description = "Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit"
 readme = "README.md"
 requires-python = ">=3.11"

{xrefkit-0.7.2 → xrefkit-0.7.3}/tests/test_ci_workflow_invariants.py

@@ -220,3 +220,38 @@ def test_shared_tools_trigger_only_consumers():
         assert not accepts_changes(filename, "pull_request", ["tools/run_quality_gate.py"])
     assert not accepts_changes("python-skill-csharp-package.yml", "pull_request", ["tools/run_import_smoke.py"])
     assert not accepts_changes("xrefkit-skills-xddp-design.yml", "pull_request", ["xrefkit/cli.py"])
+
+
+def test_pages_deployment_is_main_only_and_release_dispatch_has_no_environment():
+    data = workflow("pages.yml")
+    deploy = data["jobs"]["deploy"]
+    condition = " ".join(deploy["if"].split())
+    assert condition.startswith("github.ref == 'refs/heads/main' && (")
+    assert deploy["environment"]["name"] == "github-pages"
+    route = data["jobs"]["dispatch-release"]
+    assert route["if"] == "github.event_name == 'release'"
+    assert "environment" not in route
+    assert route["permissions"] == {"contents": "read", "actions": "write"}
+    assert data["permissions"]["pages"] == "write"
+    step = route["steps"][0]
+    assert step["env"]["RELEASE_REPOSITORY"] == "${{ github.repository }}"
+    assert step["env"]["GH_TOKEN"] == "${{ github.token }}"
+    assert "github.event.release" not in step["run"]
+
+
+@pytest.mark.parametrize("dispatch_exit", [0, 37])
+def test_pages_release_dispatch_executes_fixed_main_target_and_preserves_failure(dispatch_exit):
+    bash = shutil.which("bash")
+    if Path("C:/Program Files/Git/bin/bash.exe").is_file():
+        bash = "C:/Program Files/Git/bin/bash.exe"
+    if not bash:
+        pytest.skip("Bash is required to execute the Pages dispatch block")
+    script = workflow("pages.yml")["jobs"]["dispatch-release"]["steps"][0]["run"]
+    mock = ('set -euo pipefail\nRELEASE_REPOSITORY=synthaicode/XRefKit\n'
+            'gh() { printf "<%s>\\n" "$@"; return ' + str(dispatch_exit) + '; }\n')
+    result = subprocess.run([bash, "-c", mock + script + "\necho dispatch-complete\n"],
+                            capture_output=True, text=True)
+    assert result.returncode == dispatch_exit, result.stdout + result.stderr
+    assert result.stdout.splitlines()[:6] == ["<api>", "<--method>", "<POST>",
+        "<repos/synthaicode/XRefKit/actions/workflows/pages.yml/dispatches>", "<-f>", "<ref=main>"]
+    assert ("dispatch-complete" in result.stdout) == (dispatch_exit == 0)

{xrefkit-0.7.2 → xrefkit-0.7.3}/tests/test_cli.py

@@ -1000,7 +1000,13 @@ class CliTests(unittest.TestCase):
             )
             text = out.read_text(encoding="utf-8")
             self.assertIn("## Domain Knowledge Inputs", text)
-            self.assertIn("- rule: available and selected brownfield domain knowledge is recorded by XID only", text)
+            self.assertIn("- log_format: `compact_v1`", text)
+            self.assertIn("- operating_contract_xid: `B7A2C94F0E61`", text)
+            self.assertIn(
+                "### Selected Knowledge Inputs\n\n- target_service_structure:\n"
+                "  - `LOCAL-SERVICE-MAP-001`\n  - `LOCAL-DB-SCHEMA-001`",
+                text,
+            )
             self.assertIn("- xid: `LOCAL-SERVICE-MAP-001`", text)
             self.assertIn("content_hash: `sha256-service-map`", text)
             self.assertIn("last_verified: `2026-07-04`", text)

xrefkit-0.7.3/tests/test_compact_skill_logs.py

@@ -0,0 +1,190 @@
+import pytest
+
+from test_skill_definition_runtime import _open_run
+from test_subagent_startup import command
+from xrefkit.skillrun import _section_body
+
+
+@pytest.mark.parametrize("legacy", [False, True])
+def test_compact_and_legacy_logs_keep_evidence_through_closure(tmp_path, legacy):
+    _, log = _open_run(tmp_path)
+    text = log.read_text(encoding="utf-8")
+    marker = "- log_format: `compact_v1`\n- operating_contract_xid: `B7A2C94F0E61`\n"
+    assert marker in text
+    assert "- rule:" not in text
+    if legacy:
+        text = text.replace(marker, "", 1)
+        text = text.replace(
+            "## Token Usage\n\n", "## Token Usage\n\n- rule: legacy token guidance\n", 1
+        )
+        log.write_text(text, encoding="utf-8")
+
+    def update(*args):
+        code, output = command("skill", *args, "--log", str(log))
+        assert code == 0, output
+
+    # User data that resembles omitted template lines must survive updates.
+    note = "literal evidence\n- rule: user supplied detail\n- log_format: `compact_v1`"
+    update("tokens", "--input", "120", "--output", "30", "--note", note)
+    update("workitem", "--item", "WI-1", "--completion-criterion", "report covers target", "--status", "done", "--role", "definition_sample:executor")
+    for artifact_id, kind, target in (
+        ("OUT", "output", "report.md"), ("EVIDENCE", "evidence", "tests passed"),
+    ):
+        update("artifact", "--artifact", artifact_id, "--kind", kind, "--target", target,
+               "--item", "WI-1", "--status", "done", "--role", "definition_sample:executor")
+    update("concern", "--concern", "RISK", "--kind", "risk", "--status", "resolved",
+           "--text", "Compatibility checked", "--target", "tests passed", "--role", "definition_sample:executor")
+    for phase in ("startup", "planning", "execution"):
+        update("phase", "--phase", phase, "--status", "done", "--role", "definition_sample:executor")
+    update("verify")
+    update("phase", "--phase", "handoff", "--status", "done", "--role", "definition_sample:handoff_owner")
+    update("close")
+    text = log.read_text(encoding="utf-8")
+    assert note in text
+    assert "Compatibility checked" in text
+    assert ("- rule: each work item requires" in text) is legacy
+    assert ("- rule: outputs, evidence" in text) is legacy
+    assert ("- rule: unknowns, missing evidence" in text) is legacy
+    assert "- total: `150`" in text
+    assert "- target: report.md" in text or "target=`report.md`" in text
+    assert "## Closure Gate\n\n- status: `done`" in text
+    assert ("- rule: record tokens consumed" in text) is legacy
+    for section in ("Worklist", "Quality Gate"):
+        body, _, _ = _section_body(text, section)
+        for heading in ("Status", "Result", "Checks Performed", "Evidence", "Open Items", "Handoff"):
+            assert f"### {heading}\n" in body
+
+
+def test_workflow_log_keeps_existing_format(tmp_path):
+    log = tmp_path / "work" / "workflow.md"
+    code, output = command(
+        "workflow", "run", "--root", str(tmp_path), "--task", "Inspect target",
+        "--completion-condition", "Target inspected", "--out", str(log),
+    )
+    assert code == 0, output
+    original = log.read_text(encoding="utf-8")
+    assert "log_format" not in original
+    assert "- rule: do not treat the instruction" in original
+    code, output = command("skill", "tokens", "--log", str(log), "--total", "20")
+    assert code == 0, output
+    assert "- rule: record tokens consumed" in log.read_text(encoding="utf-8")
+
+
+def test_compaction_only_removes_template_rules_and_preserves_task(monkeypatch, tmp_path):
+    from xrefkit import skillrun
+
+    render = skillrun._render_log
+    captured = {}
+
+    def capture(**kwargs):
+        captured.update(kwargs)
+        return render(**kwargs)
+
+    monkeypatch.setattr(skillrun, "_render_log", capture)
+    _open_run(tmp_path)
+    captured["task"] = "Keep these literal lines:\n- rule: task requirement\n- log_format: `other`"
+    compact = render(**captured)
+    verbose = render(**{**captured, "compact": False})
+    assert captured["task"] in compact
+    assert len(compact.encode("utf-8")) < len(verbose.encode("utf-8")) * 0.8
+
+    # Every non-boilerplate line survives in the same order, including reports.
+    def data_lines(text):
+        return [line for line in text.splitlines() if line and not line.startswith((
+            "- rule:", "- log_format:", "- operating_contract_xid:",
+        ))]
+
+    assert data_lines(compact) == data_lines(verbose)
+
+
+def test_dashboard_payload_is_identical_for_compact_and_verbose_runs(monkeypatch, tmp_path):
+    import json
+    import os
+    from datetime import datetime, timezone
+    from itertools import count
+    from uuid import UUID
+
+    from xrefkit import dashboard, skillrun
+
+    render = skillrun._render_log
+    captured = {}
+
+    def capture(**kwargs):
+        captured.update(kwargs)
+        return render(**kwargs)
+
+    monkeypatch.setattr(skillrun, "_render_log", capture)
+    _, log = _open_run(tmp_path)
+    provenance = {"capability": {"origin": "explicit_input", "selected_value": "repository inspection"}}
+
+    class FixedDatetime(datetime):
+        @classmethod
+        def now(cls, tz=None):
+            fixed = cls(2026, 10, 25, 12, 0, tzinfo=timezone.utc)
+            return fixed.astimezone(tz) if tz else fixed.replace(tzinfo=None)
+
+    monkeypatch.setattr(skillrun, "datetime", FixedDatetime)
+    monkeypatch.setattr(dashboard, "datetime", FixedDatetime)
+    snapshots = []
+    for compact in (False, True):
+        event_ids = count(1)
+        monkeypatch.setattr(skillrun.uuid, "uuid4", lambda: UUID(int=next(event_ids)))
+        identity = {**captured["definition_identity"], "runtime_provenance": json.dumps(
+            provenance, sort_keys=True, separators=(",", ":") if compact else None,
+        )}
+        log.write_text(render(**{**captured, "definition_identity": identity, "compact": compact}), encoding="utf-8")
+
+        def snapshot():
+            # Compare the whole public payload, with no fields removed. The same
+            # file path and frozen clocks make file/observation timestamps equal.
+            os.utime(log, (1792929600, 1792929600))
+            return dashboard.build_payload(tmp_path, log.parent)
+
+        def update(*args):
+            code, output = command("skill", *args, "--log", str(log))
+            assert code == 0, output
+
+        initial = snapshot()
+        assert "token_usage" in {item["code"] for item in initial["runs"][0]["missing_information"]}
+        update("workitem", "--item", "WI-1", "--text", "Inspect target",
+               "--completion-criterion", "report covers target", "--status", "done", "--role", "definition_sample:executor")
+        for artifact_id, kind, target in (("OUT-1", "output", "report.md"), ("EVD-1", "evidence", "tests passed")):
+            update("artifact", "--artifact", artifact_id, "--kind", kind, "--target", target,
+                   "--item", "WI-1", "--status", "done", "--role", "definition_sample:executor")
+        update("concern", "--concern", "RISK-1", "--kind", "risk", "--status", "resolved",
+               "--text", "Compatibility checked", "--target", "tests passed", "--role", "definition_sample:executor")
+        update("correlate", "--run-id", captured["run_id"], "--mcp-session-id", "mcp-1", "--repository-fingerprint", "repo-1")
+        update("routing", "--selected-skill", "definition_sample", "--candidate", "definition_sample", "--reason", "best match")
+        update("knowledge", "--action", "search", "--query", "service map", "--status", "hit", "--xid", "SERVICE123456")
+        update("knowledge", "--action", "load", "--xid", "SERVICE123456", "--content-hash", "hash-1")
+        update("knowledge", "--action", "apply", "--xid", "SERVICE123456", "--content-hash", "hash-1", "--target", "OUT-1")
+        update("feedback", "--kind", "human", "--status", "accepted", "--note", "accepted")
+        update("feedback", "--kind", "outcome", "--status", "successful", "--note", "successful")
+        update("tokens", "--input", "120", "--output", "30")
+        populated = snapshot()
+        run = populated["runs"][0]
+        assert run["missing_information"] == []
+        assert run["counts"]["work_items"] == 1
+        assert run["counts"]["artifacts"] == 2
+        assert run["counts"]["risks"] == 1
+        assert run["loaded_xids"] == run["used_xids"] == ["SERVICE123456"]
+        assert run["definition_format"] == "skill_definition_v1"
+        assert run["definition_xid"] == "ABCDEF123456"
+        assert run["definition_sha256"] == captured["definition_identity"]["sha256"]
+        assert run["capability"] == "repository inspection"
+        assert {event["event"] for event in run["observation_events"]} >= {
+            "skill.routed", "knowledge.search", "knowledge.loaded", "knowledge.applied", "human.feedback", "outcome.feedback",
+        }
+        for phase in ("startup", "planning", "execution"):
+            update("phase", "--phase", phase, "--status", "done", "--role", "definition_sample:executor")
+        update("verify")
+        update("phase", "--phase", "handoff", "--status", "done", "--role", "definition_sample:handoff_owner")
+        update("close")
+        closed = snapshot()
+        assert closed["runs"][0]["status"] == "closed"
+        text = log.read_text(encoding="utf-8")
+        assert json.loads(skillrun._log_field(text, "definition_runtime_provenance")) == provenance
+        assert skillrun._parse_token_usage(text) == {"status": "recorded", "input": "120", "output": "30", "total": "150"}
+        snapshots.append((initial, populated, closed))
+
+    assert snapshots[0] == snapshots[1]

{xrefkit-0.7.2 → xrefkit-0.7.3}/xrefkit/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.7.2"
+__version__ = "0.7.3"

{xrefkit-0.7.2 → xrefkit-0.7.3}/xrefkit/mcp/catalog.py

@@ -3069,6 +3069,14 @@ def _reporting_protocol() -> dict[str, object]:
             "when relevant, distinguish what evidence establishes from remaining human judgment and state the condition requiring reconsideration; keep supporting evidence reachable",
             "a reader perspective must not imply unverified areas are safe to ignore, prior evaluations still apply without checking their conditions, or a plausible explanation proves correctness or understanding",
             "reading guidance adds no approval gate or evaluation criterion; preserve unknowns instead of inventing reader purpose, authority, or a decision framework",
+            "report a blocking circular decision or work dependency at identification and verified resolution in the task format; do not repeat unchanged alerts or use an always-visible Attention Pet, new Pet, or monitoring service",
+            "show the closed dependency path, grounding each edge in original utterances or instructions with reachable references or short quotations; distinguish confirmed from inferred edges and label a cycle with an inferred edge as suspected",
+            "identify the decisions or work stopped by the cycle and candidates to break it, naming the edge each candidate would remove or independently satisfy and any required decision or authority; a candidate is not an adopted premise",
+            "distinguish blocking cycles from ambiguity, contradiction, repetition, and normal iterative improvement with an executable next step; do not invent missing edges",
+            "after a premise or prerequisite changes, recheck the affected path against current instructions; fixing a value alone does not establish resolution",
+            "report resolution only when the checked cycle is actually broken: name the removed or independently satisfied edge and the decision or work now able to proceed; preserve other open cycles and unknowns",
+            "when resolution is conditional, say resolved under this assumption, name the assumption and the condition requiring rechecking; reuse the finding or task reference when available",
+            "dependency evidence reconstructs available conversation and task records; do not claim access to the model's actual internal reference history",
             "preserve evidence and open items",
             "keep workflow status separate from domain gate verdict",
             "do not use done to hide unresolved unknowns, risks, or handoff conditions",

{xrefkit-0.7.2 → xrefkit-0.7.3}/xrefkit/skillrun.py

@@ -519,6 +519,11 @@ def _start_decision_trace_checkpoint(
     return checkpoint, None
 
 
+def _is_compact_log(text: str) -> bool:
+    # Only the generated header selects formatting; task and note text cannot.
+    return text.startswith("# Skill Run Log\n\n- log_format: `compact_v1`\n")
+
+
 def _render_log(
     *,
     run_id: str,
@@ -548,7 +553,15 @@ def _render_log(
     decision_trace_checkpoint: dict[str, object] | None = None,
     definition_identity: dict[str, str] | None = None,
     runtime_binding_source: str = "legacy_meta_compatibility",
+    compact: bool = False,
 ) -> str:
+    def rule(body: str) -> str:
+        return "" if compact else f"- rule: {body}"
+
+    format_header = (
+        "- log_format: `compact_v1`\n- operating_contract_xid: `B7A2C94F0E61`\n"
+        if compact else ""
+    )
     tier_label = model_tier or "unset"
     quality_policy = "required" if model_tier in QUALITY_REQUIRED_TIERS else "optional"
     contract_lines = "\n".join(f"- {key}: `{value}`" for key, value in os_contract.items())
@@ -660,7 +673,7 @@ def _render_log(
         )
     return f"""# Skill Run Log
 
-- run_id: `{run_id}`
+{format_header}- run_id: `{run_id}`
 {flow_lines}
 - mcp_session_id: `-`
 - repository_fingerprint: `-`
@@ -678,7 +691,7 @@ def _render_log(
 ## Skill Load Gate
 
 - status: `opened_by_xrefkit_skill_run`
-- rule: do not open or execute the Skill procedure until this runtime envelope exists
+{rule('do not open or execute the Skill procedure until this runtime envelope exists')}
 
 ## Runtime Role Assignment
 
@@ -703,7 +716,7 @@ def _render_log(
 
 - workflow_protocol: `{workflow_protocol}`
 - checker: `protocol-owned deterministic workflow-progression verification via xrefkit skill verify`
-- rule: checker responsibility is assigned by the runtime workflow protocol, not repeated in Skill meta
+{rule('checker responsibility is assigned by the runtime workflow protocol, not repeated in Skill meta')}
 
 ## OS Contract
 
@@ -719,17 +732,17 @@ def _render_log(
 - responsibility: `{runtime_responsibility}`
 - execution_mode: `{execution_mode}`
 - instruction_basis: `run.task`
-- rule: derive and persist the runtime binding from the current instruction and work-item state; model_requirements remains a separate model-eligibility input
+{rule('derive and persist the runtime binding from the current instruction and work-item state; model_requirements remains a separate model-eligibility input')}
 {legacy_runtime_binding_lines}
 
 ## Startup Inputs
 
-- rule: when work starts from a prior handoff, the receiving startup must name the handoff source log and verify that its closure gate already passed
+{rule('when work starts from a prior handoff, the receiving startup must name the handoff source log and verify that its closure gate already passed')}
 {handoff_source_lines}
 
 ## Domain Knowledge Inputs
 
-- rule: available and selected brownfield domain knowledge is recorded by XID only; load full bodies through XID resolution, not local paths
+{rule('available and selected brownfield domain knowledge is recorded by XID only; load full bodies through XID resolution, not local paths')}
 - requirements:
 {requirement_lines}
 
@@ -743,13 +756,13 @@ def _render_log(
 
 ### Used Knowledge Refs
 
-- rule: record actually consulted domain knowledge XIDs as runtime artifacts or evidence before handoff
+{rule('record actually consulted domain knowledge XIDs as runtime artifacts or evidence before handoff')}
 - none recorded yet
 
 ## MCP Correlation
 
 - status: `pending`
-- rule: bind this Skill Run to one MCP session with `xrefkit skill correlate` after `bind_skill_run` returns
+{rule('bind this Skill Run to one MCP session with `xrefkit skill correlate` after `bind_skill_run` returns')}
 
 ## Skill Routing Trace
 
@@ -759,32 +772,32 @@ def _render_log(
 ## Knowledge Search Trace
 
 - status: `pending`
-- rule: record search queries, hits, misses, and fallback decisions with `xrefkit skill knowledge --action search`
+{rule('record search queries, hits, misses, and fallback decisions with `xrefkit skill knowledge --action search`')}
 
 ## Loaded Knowledge Inputs
 
 - status: `pending`
-- rule: record each XID body actually loaded into model context with `xrefkit skill knowledge --action load`
+{rule('record each XID body actually loaded into model context with `xrefkit skill knowledge --action load`')}
 
 ## Knowledge Application Trace
 
 - status: `pending`
-- rule: link each applied XID to a judgment or artifact with `xrefkit skill knowledge --action apply`
+{rule('link each applied XID to a judgment or artifact with `xrefkit skill knowledge --action apply`')}
 
 ## Human Feedback
 
 - status: `pending`
-- rule: record human acceptance, correction, or rejection with `xrefkit skill feedback --kind human`
+{rule('record human acceptance, correction, or rejection with `xrefkit skill feedback --kind human`')}
 
 ## Human Evaluation
 
 - status: `pending`
-- rule: optional run-boundary evaluation; control returns to the human without waiting, and a subsequent request may record a human-confirmed relationship with `xrefkit skill evaluate`
+{rule('optional run-boundary evaluation; control returns to the human without waiting, and a subsequent request may record a human-confirmed relationship with `xrefkit skill evaluate`')}
 
 ## Outcome Feedback
 
 - status: `pending`
-- rule: record downstream outcome evidence with `xrefkit skill feedback --kind outcome`
+{rule('record downstream outcome evidence with `xrefkit skill feedback --kind outcome`')}
 
 ## Worklist
 
@@ -823,12 +836,12 @@ The workflow protocol worklist has not started.
 ## Concrete Work Items
 
 - status: `pending`
-- rule: task-specific work items must be added with `xrefkit skill workitem` and closed as `done` or `escalated`
+{rule('task-specific work items must be added with `xrefkit skill workitem` and closed as `done` or `escalated`')}
 
 ## Runtime Artifacts
 
 - status: `pending`
-- rule: outputs, evidence, checks, judgments, sources, and handoff links must be added with `xrefkit skill artifact`
+{rule('outputs, evidence, checks, judgments, sources, and handoff links must be added with `xrefkit skill artifact`')}
 
 ## Execution Role
 
@@ -845,7 +858,7 @@ The workflow protocol worklist has not started.
 - status: `pending`
 - model_tier: `{tier_label}`
 - policy: `{quality_policy}`
-- rule: declare acceptance check items as `check`-kind artifacts at planning; an independent quality reviewer sets each to `done` (pass) or `blocked` (fail) with `xrefkit skill artifact`; domain reviews run as separate review Skills orchestrated by the main session and linked here. Required when model_tier is `standard` or `heavy`; optional otherwise
+{rule('declare acceptance check items as `check`-kind artifacts at planning; an independent quality reviewer sets each to `done` (pass) or `blocked` (fail) with `xrefkit skill artifact`; domain reviews run as separate review Skills orchestrated by the main session and linked here. Required when model_tier is `standard` or `heavy`; optional otherwise')}
 
 ### Report
 
@@ -877,17 +890,17 @@ No quality checklist items have been recorded yet.
 ## Unknowns And Risks
 
 - status: `pending`
-- rule: unknowns, missing evidence, risks, and unsupported assumptions must remain explicit and must be resolved, escalated, or linked before closure
+{rule('unknowns, missing evidence, risks, and unsupported assumptions must remain explicit and must be resolved, escalated, or linked before closure')}
 
 ## Closure Gate
 
 - status: `pending`
-- rule: close only after execution, check, log, unknown/risk, and handoff rows are complete or explicitly escalated
+{rule('close only after execution, check, log, unknown/risk, and handoff rows are complete or explicitly escalated')}
 
 ## Handoff
 
 - status: `pending`
-- rule: record outputs, unresolved items, next owner, and human decision points
+{rule('record outputs, unresolved items, next owner, and human decision points')}
 
 ## Token Usage
 
@@ -895,7 +908,7 @@ No quality checklist items have been recorded yet.
 - input: `-`
 - output: `-`
 - total: `-`
-- rule: record tokens consumed by this skill run with `xrefkit skill tokens` (informational; does not gate closure)
+{rule('record tokens consumed by this skill run with `xrefkit skill tokens` (informational; does not gate closure)')}
 """
 
 
@@ -1570,8 +1583,9 @@ def _replace_concrete_work_items_section(text: str, items: list[dict[str, str]])
         "## Concrete Work Items",
         "",
         f"- status: `{status}`",
-        "- rule: each work item requires a completion criterion; use unknown, blocked, or escalated with a reason when the criterion cannot yet be defined",
     ]
+    if not _is_compact_log(text):
+        lines.append("- rule: each work item requires a completion criterion; use unknown, blocked, or escalated with a reason when the criterion cannot yet be defined")
     lines.extend(_render_workitem_line(**item) for item in items)
     new_body = "\n".join(lines) + "\n"
     return text[:start] + new_body + text[end:]
@@ -1710,8 +1724,9 @@ def _replace_runtime_artifacts_section(text: str, artifacts: list[dict[str, str]
         "## Runtime Artifacts",
         "",
         f"- status: `{status}`",
-        "- rule: outputs, evidence, checks, judgments, sources, and handoff links must be added with `xrefkit skill artifact`",
     ]
+    if not _is_compact_log(text):
+        lines.append("- rule: outputs, evidence, checks, judgments, sources, and handoff links must be added with `xrefkit skill artifact`")
     lines.extend(_render_artifact_line(**artifact) for artifact in artifacts)
     new_body = "\n".join(lines) + "\n"
     return text[:start] + new_body + text[end:]
@@ -1844,8 +1859,9 @@ def _replace_unknowns_and_risks_section(text: str, concerns: list[dict[str, str]
         "## Unknowns And Risks",
         "",
         f"- status: `{_overall_concern_status(concerns)}`",
-        "- rule: unknowns, missing evidence, risks, and unsupported assumptions must remain explicit and must be resolved, escalated, or linked before closure",
     ]
+    if not _is_compact_log(text):
+        lines.append("- rule: unknowns, missing evidence, risks, and unsupported assumptions must remain explicit and must be resolved, escalated, or linked before closure")
     lines.extend(_render_concern_line(**concern) for concern in concerns)
     new_body = "\n".join(lines) + "\n"
     return text[:start] + new_body + text[end:]
@@ -2400,7 +2416,8 @@ def _parse_token_usage(text: str) -> dict[str, str] | None:
 
 
 def _render_token_usage_section(
-    *, input_value: str, output_value: str, total_value: str, note: str | None
+    *, input_value: str, output_value: str, total_value: str, note: str | None,
+    include_rule: bool = True,
 ) -> str:
     lines = [
         "## Token Usage",
@@ -2409,8 +2426,9 @@ def _render_token_usage_section(
         f"- input: `{input_value}`",
         f"- output: `{output_value}`",
         f"- total: `{total_value}`",
-        "- rule: record tokens consumed by this skill run with `xrefkit skill tokens` (informational; does not gate closure)",
     ]
+    if include_rule:
+        lines.append("- rule: record tokens consumed by this skill run with `xrefkit skill tokens` (informational; does not gate closure)")
     if note:
         lines.append(f"- note: {note}")
     return "\n".join(lines) + "\n"
@@ -2900,6 +2918,7 @@ def update_token_usage(args) -> SkillRunResult:
         output_value=str(output_tokens) if output_tokens is not None else "-",
         total_value=str(total_tokens),
         note=note,
+        include_rule=not _is_compact_log(text),
     )
     text = _replace_token_usage_section(text, new_body)
     text = _append_phase_event(
@@ -2968,7 +2987,7 @@ def run_skill(args) -> SkillRunResult:
             definition_identity.update({
                 "adoption_path": adoption["path"], "adoption_sha256": adoption["sha256"],
                 "invocation_path": str(meta_arg or getattr(args, "definition", "")),
-                "runtime_provenance": json.dumps(adapter["runtime"], sort_keys=True),
+                "runtime_provenance": json.dumps(adapter["runtime"], sort_keys=True, separators=(",", ":")),
             })
         definition_maturity = "unassessed"
         if adapter and "current_adoption" in adapter:
@@ -2977,7 +2996,7 @@ def run_skill(args) -> SkillRunResult:
                 return SkillRunResult(ok=False, skill_id=skill_id, skill_doc=str(meta_path), run_log=None,
                                       errors=["explicit governance must match current repository adoption record"])
             governance_arg = current["governance_path"]
-            definition_identity["current_adoption_provenance"] = json.dumps(current, sort_keys=True)
+            definition_identity["current_adoption_provenance"] = json.dumps(current, sort_keys=True, separators=(",", ":"))
         if governance_arg:
             governance_path = (root / governance_arg).resolve()
             try:
@@ -3011,7 +3030,7 @@ def run_skill(args) -> SkillRunResult:
                       **({"native_source": adapter["adoption"]} if native_adapter
                          else {"legacy_receipt": adapter["runtime"][key]})}
                 for key in RUNTIME_FIELDS
-            }, sort_keys=True)
+            }, sort_keys=True, separators=(",", ":"))
         if not capability or not tuning or not responsibility or not execution_mode_arg:
             return SkillRunResult(ok=False, skill_id=skill_id, skill_doc=str(meta_path), run_log=None,
                                   errors=["definition-backed runs require --capability, --tuning, --responsibility, and --execution-mode"])
@@ -3021,7 +3040,7 @@ def run_skill(args) -> SkillRunResult:
                        "role_responsibilities": [f"executor: {responsibility}"]})
         if adapter and adapter.get("source_kind") != "native_v1":
             parsed.update({key: receipt["value"] for key, receipt in adapter["legacy_runtime_policy"].items()})
-            definition_identity["legacy_policy_provenance"] = json.dumps(adapter["legacy_runtime_policy"], sort_keys=True)
+            definition_identity["legacy_policy_provenance"] = json.dumps(adapter["legacy_runtime_policy"], sort_keys=True, separators=(",", ":"))
     else:
         parsed = _parse_meta_lines(meta_path.read_text(encoding="utf-8"))
     domain_knowledge, domain_knowledge_errors = _prepare_domain_knowledge_context(
@@ -3226,6 +3245,7 @@ def run_skill(args) -> SkillRunResult:
         decision_trace_checkpoint=checkpoint,
         definition_identity=definition_identity,
         runtime_binding_source="instruction_derived" if definition_arg else "legacy_meta_compatibility",
+        compact=True,
     )
     kickoff = None
     if skill_id in {"skill_flow_authoring", "knowledge_ontology_management"}:

{xrefkit-0.7.2 → xrefkit-0.7.3/xrefkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xrefkit
-Version: 0.7.2
+Version: 0.7.3
 Summary: Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit
 Author: synthaicode
 License: MIT License

{xrefkit-0.7.2 → xrefkit-0.7.3}/xrefkit.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ tests/test_ci_workflow_invariants.py
 tests/test_cli.py
 tests/test_code_constraint_definition.py
 tests/test_collect_analyzer_sarif.py
+tests/test_compact_skill_logs.py
 tests/test_constraint_derivation_family_definition.py
 tests/test_constraint_derivation_selected_family.py
 tests/test_contribution_adoption_bytes.py