create-egregore 0.21.6 → 0.22.0

package/runtime/pi/egregore_runtime/quest_cli.py

@@ -3,13 +3,13 @@
 from __future__ import annotations
 
 import argparse
-import json
 import os
 from pathlib import Path
 from uuid import uuid4
 
+from . import held
 from .contracts import Permission
-from .policy import scope_allows_path
+from .policy import action_for, check
 from .quests import CanonicalQuestService
 from .runtime import local_runtime
 
@@ -42,9 +42,12 @@ def _require(
     decision = runtime.authorize(actor, permission, (resource,))
     if not decision.allowed:
         raise PermissionError("; ".join(decision.reasons) or f"quest {permission.value} denied")
-    if canonical_path and not scope_allows_path(canonical_path, decision.scopes):
+    if not canonical_path:
+        return decision, None
+    verdict = check(decision, canonical_path, action_for(decision.permission), root=runtime.canonical_root)
+    if not verdict.allowed:
         raise PermissionError("quest path is outside the actor's authorized scope")
-    return decision
+    return decision, verdict.resolved  # readers open the path the predicate resolved
 
 
 def _row(snapshot, *, detail: bool = False):
@@ -67,40 +70,34 @@ def _row(snapshot, *, detail: bool = False):
 
 def _list(args):
     runtime, actor, service = _context()
-    decision = _require(runtime, actor, Permission.READ, "quests")
+    decision, _ = _require(runtime, actor, Permission.READ, "quests")
     rows = [
         _row(snapshot)
         for snapshot in service.list(
             actor,
             include_completed=args.all,
-            authorized_scopes=decision.scopes,
+            decision=decision,
         )
     ]
-    print(json.dumps({"quests": rows}, ensure_ascii=False))
-    return 0
+    return held.emit(decision, {"quests": rows}, root=runtime.canonical_root, each=("quests", "canonical_path"))
 
 
 def _show(args):
     runtime, actor, service = _context()
-    _require(
+    decision, source = _require(
         runtime,
         actor,
         Permission.READ,
         f"quest:{args.slug}",
         canonical_path=service.canonical_path(args.slug),
     )
-    print(json.dumps({"quest": _row(service.read(actor, args.slug), detail=True)}, ensure_ascii=False))
-    return 0
+    row = _row(service.read(actor, args.slug, source=source), detail=True)
+    return held.emit(decision, {"quest": row}, root=runtime.canonical_root, paths=(row["canonical_path"],))
 
 
-def _write_result(snapshot, receipt):
-    print(
-        json.dumps(
-            {"quest": _row(snapshot), "writeback": receipt.to_dict()},
-            ensure_ascii=False,
-        )
-    )
-    return 0 if receipt.status.value in {"accepted", "partial"} else 1
+def _write_result(runtime, actor, snapshot, receipt):
+    return held.emit_for(runtime, actor, {"quest": _row(snapshot), "writeback": receipt.to_dict()}) or (
+        0 if receipt.status.value in {"accepted", "partial"} else 1)
 
 
 def _create(args):
@@ -121,7 +118,7 @@ def _create(args):
         projects=args.project,
         threads=args.thread,
     )
-    return _write_result(snapshot, receipt)
+    return _write_result(runtime, actor, snapshot, receipt)
 
 
 def _prioritize(args):
@@ -135,7 +132,7 @@ def _prioritize(args):
     )
     value = PRIORITIES.get(args.priority, int(args.priority) if args.priority.isdigit() else -1)
     snapshot, receipt = service.prioritize(actor, slug=args.slug, priority=value)
-    return _write_result(snapshot, receipt)
+    return _write_result(runtime, actor, snapshot, receipt)
 
 
 def _transition(args):
@@ -153,7 +150,7 @@ def _transition(args):
         status=args.command,
         outcome=getattr(args, "outcome", None),
     )
-    return _write_result(snapshot, receipt)
+    return _write_result(runtime, actor, snapshot, receipt)
 
 
 def _contribute(args):
@@ -166,7 +163,7 @@ def _contribute(args):
         canonical_path=service.canonical_path(args.slug),
     )
     snapshot, receipt = service.contribute(actor, slug=args.slug, text=args.text)
-    return _write_result(snapshot, receipt)
+    return _write_result(runtime, actor, snapshot, receipt)
 
 
 def _parser():

package/runtime/pi/egregore_runtime/question_cli.py

@@ -10,6 +10,7 @@ from pathlib import Path
 import sys
 from uuid import uuid4
 
+from . import held
 from .contracts import RetrievalHit, RetrieverHealth
 from .errors import AuthorizationDenied
 from .questions import CanonicalQuestionService, QuestionLifecycleError
@@ -90,8 +91,9 @@ def _receipt(receipt, canonical_path: str) -> dict[str, object]:
 
 def _create(args: argparse.Namespace) -> int:
     runtime, memory = _runtime(push_remote=not args.no_push)
+    actor = _actor(runtime)
     receipt = CanonicalQuestionService(runtime, memory).create(
-        _actor(runtime),
+        actor,
         sender_alias=args.sender,
         recipient_alias=args.recipient,
         recipient_actor_id=args.recipient_actor_id,
@@ -103,33 +105,35 @@ def _create(args: argparse.Namespace) -> int:
         question_intent=args.question_intent,
         context_mode=args.context_mode,
     )
-    print(json.dumps(_receipt(receipt, receipt.artifact.canonical_path), ensure_ascii=False))
-    return 0 if receipt.status.value in {"accepted", "partial"} else 1
+    return held.emit_for(runtime, actor, _receipt(receipt, receipt.artifact.canonical_path)) or (
+        0 if receipt.status.value in {"accepted", "partial"} else 1)
 
 
 def _pending(args: argparse.Namespace) -> int:
     runtime, memory = _runtime(push_remote=False)
-    rows = CanonicalQuestionService(runtime, memory).pending(_actor(runtime), limit=args.limit)
-    print(json.dumps({"questions": [row.to_dict() for row in rows]}, ensure_ascii=False))
-    return 0
+    actor = _actor(runtime)
+    rows = CanonicalQuestionService(runtime, memory).pending(actor, limit=args.limit)
+    return held.emit_for(runtime, actor, {"questions": [row.to_dict() for row in rows]},
+                         each=("questions", "canonical_path"))
 
 
 def _open(args: argparse.Namespace) -> int:
     runtime, memory = _runtime(push_remote=False)
-    print(CanonicalQuestionService(runtime, memory).open(_actor(runtime), args.path), end="")
-    return 0
+    actor = _actor(runtime)
+    return held.emit_for(runtime, actor, CanonicalQuestionService(runtime, memory).open(actor, args.path),
+                         paths=("memory/" + args.path.removeprefix("memory/"),), render=str, end="")
 
 
 def _answer(args: argparse.Namespace) -> int:
     runtime, memory = _runtime(push_remote=not args.no_push)
+    actor = _actor(runtime)
     receipt = CanonicalQuestionService(runtime, memory).answer(
-        _actor(runtime),
+        actor,
         canonical_path=args.path,
         answer=args.body,
         responder_alias=args.responder,
     )
-    print(json.dumps(_receipt(receipt, receipt.artifact.canonical_path), ensure_ascii=False))
-    return 0
+    return held.emit_for(runtime, actor, _receipt(receipt, receipt.artifact.canonical_path))
 
 
 def _parser() -> argparse.ArgumentParser:

package/runtime/pi/egregore_runtime/questions.py

@@ -24,7 +24,7 @@ from .artifacts import (
 )
 from .contracts import ActorContext, CanonicalArtifact, Permission, WritebackEvent, WritebackStatus
 from .errors import AuthorizationDenied
-from .policy import scope_allows_path
+from .policy import check
 from .runtime import EgregoreRuntime
 
 
@@ -191,8 +191,9 @@ class CanonicalQuestionService:
         rows: list[Path] = []
         for path in sorted(directory.glob("*.md"), reverse=True):
             canonical = f"memory/{path.relative_to(self.memory_root).as_posix()}"
-            if scope_allows_path(canonical, decision.scopes):
-                rows.append(path)
+            verdict = check(decision, canonical, "read", root=self.memory_root)
+            if verdict.allowed:
+                rows.append(verdict.resolved)
         return tuple(rows)
 
     @staticmethod
@@ -235,18 +236,17 @@ class CanonicalQuestionService:
     def open(self, actor: ActorContext, canonical_path: str) -> str:
         relative = self._relative_path(canonical_path)
         decision = self.runtime.authorize(actor, Permission.READ)
-        if not decision.allowed or not scope_allows_path(
-            f"memory/{relative}", decision.scopes
-        ):
+        verdict = check(decision, f"memory/{relative}", "read", root=self.memory_root)
+        if not verdict.allowed:
             raise AuthorizationDenied("question is outside the actor read scope")
-        source = (self.memory_root / relative).resolve()
-        fields, _ = split_frontmatter(source.read_text(encoding="utf-8"))
+        raw = verdict.resolved.read_text(encoding="utf-8")
+        fields, _ = split_frontmatter(raw)
         if not self._addressed_to_actor(fields, actor):
             raise AuthorizationDenied("question is not addressed to the active actor")
 
-        content = self.runtime.open_source(actor, f"memory/{relative}")
+        content = self.runtime.open_source(actor, f"memory/{relative}")  # redacted: the type is read from the source
         document = parse_canonical_markdown(
-            content,
+            raw,
             canonical_path=relative,
             default_org_id=actor.profile.org_id,
         )

package/runtime/pi/egregore_runtime/quests.py

@@ -15,8 +15,8 @@ from .artifacts import (
     parse_canonical_markdown,
     split_frontmatter,
 )
-from .contracts import ActorContext, CanonicalArtifact, WritebackEvent
-from .policy import scope_allows_path
+from .contracts import ActorContext, CanonicalArtifact, WritebackEvent, PolicyDecision
+from .policy import check, action_for
 
 
 QUEST_STATUSES = frozenset({"active", "paused", "completed"})
@@ -291,13 +291,14 @@ class CanonicalQuestService:
         current = replace(snapshot, document=document)
         return current, self.write_document(actor, document)
 
-    def read(self, actor: ActorContext, slug: str) -> QuestSnapshot:
-        path = self._path(slug)
+    def read(self, actor: ActorContext, slug: str, *, source: Path | None = None) -> QuestSnapshot:
+        """Read a quest; a read surface passes the ``source`` the predicate resolved."""
+        path = source or self._path(slug)
         if not path.is_file():
             raise ValueError(f"quest does not exist: {_slug(slug)}")
         return parse_quest_markdown(
             path.read_text(encoding="utf-8"),
-            slug=path.stem,
+            slug=self._path(slug).stem,
             org_id=actor.profile.org_id,
         )
 
@@ -306,7 +307,7 @@ class CanonicalQuestService:
         actor: ActorContext,
         *,
         include_completed: bool = False,
-        authorized_scopes: tuple[str, ...] | None = None,
+        decision: PolicyDecision,
     ) -> tuple[QuestSnapshot, ...]:
         quest_dir = self.memory_root / "quests"
         if not quest_dir.is_dir():
@@ -316,11 +317,10 @@ class CanonicalQuestService:
             if path.name in {"_template.md", "index.md"}:
                 continue
             canonical = f"memory/quests/{path.name}"
-            if authorized_scopes is not None and not scope_allows_path(
-                canonical, authorized_scopes
-            ):
+            verdict = check(decision, canonical, action_for(decision.permission), root=self.memory_root)
+            if not verdict.allowed:
                 continue
-            snapshots.append(self.read(actor, path.stem))
+            snapshots.append(parse_quest_markdown(verdict.resolved.read_text(encoding="utf-8"), slug=path.stem, org_id=actor.profile.org_id))
         if not include_completed:
             snapshots = [row for row in snapshots if row.status != "completed"]
         return tuple(sorted(snapshots, key=lambda row: (row.priority, row.started), reverse=True))