pdl-taskmaster 2.5.0__tar.gz → 2.5.1__tar.gz

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pdl-taskmaster
-Version: 2.5.0
+Version: 2.5.1
 Summary: Deterministic protocol governance and bounded AI agent harness
 Author: PDL-Standard Contributors
 License: MIT

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/docs/adr/README.md

@@ -18,6 +18,7 @@
 | [ADR-0014](0014-dual-plane-boundary-and-wire-conformance.md) | Accepted | Dual-plane boundary architecture: positive structural guidance, wire-level Pydantic contract enforcement, and tripartite clause governance. |
 | [ADR-0015](0015-model-synthesized-verification-and-confinement-boundaries.md) | Proposed | Model-synthesized verification and confinement boundaries in ephemeral sandboxes. |
 | [ADR-0016](0016-pydantic-ssot-wire-and-deliverable-boundary-enforcement.md) | Accepted | Pydantic Single Source of Truth (SSOT) for wire and deliverable boundary enforcement. |
+| [ADR-0017](0017-dual-plane-runtime-realignment-and-mrv-solver-governance.md) | Accepted | Dual-Plane Runtime Realignment: System 1 (Jev) Baseline & Constraint-Ordered Solver Governance. |
 
 The records are intentionally separated so UI, context construction, execution
 isolation, output representation, and reasoning policy can evolve without

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/__init__.py

@@ -1,6 +1,6 @@
 """PDL-Taskmaster: Deterministic protocol governance and bounded AI agent harnesses."""
 
-__version__ = "2.5.0"
+__version__ = "2.5.1"
 __protocol_version__ = "v2"
 
 __all__ = ["__version__", "__protocol_version__"]

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/host/app.py

@@ -84,6 +84,7 @@ class PDLtHost:
                     higher_priority_constraints=self.higher_priority_constraints,
                     available_execution_tools=[],
                     render_compact=self.render_compact,
+                    sys1_client=getattr(self.worker, "sys1_client", None),
                 )
             except Exception as exc:
                 # Graceful degradation: a session with no committed protocol
@@ -99,6 +100,7 @@ class PDLtHost:
                 available_execution_tools=[],
                 workspace_root=self.workspace_root,
                 render_compact=self.render_compact,
+                sys1_client=getattr(self.worker, "sys1_client", None),
             )
         self.engine = engine
         if self.observation_dir is not None:

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/host/cli.py

@@ -73,6 +73,12 @@ def _cmd_verify(argv: list[str]) -> int:
     return verify_main()
 
 
+def _cmd_viewer(argv: list[str]) -> int:
+    from pdl_taskmaster.tools.viewer_server import main as viewer_main
+
+    return viewer_main(argv)
+
+
 def _main_impl(argv: list[str] | None = None) -> int:
     if argv is None:
         argv = sys.argv[1:]
@@ -89,6 +95,8 @@ def _main_impl(argv: list[str] | None = None) -> int:
         return _cmd_init(argv[1:])
     if subcmd == "verify":
         return _cmd_verify(argv[1:])
+    if subcmd in {"viewer", "ui", "dashboard"}:
+        return _cmd_viewer(argv[1:])
 
     # Default: route all other invocations to REPL
     from pdl_taskmaster.host.repl import main as repl_main

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/host/repl.py

@@ -13,9 +13,36 @@ from typing import Any, TextIO
 import sys
 
 
-ROOT = Path(__file__).resolve().parents[3]
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
+def _resolve_repo_root() -> Path | None:
+    """Resolve the repository root when running from a dev/editable install.
+
+    Returns None when running from a wheel-installed site-packages layout
+    where the repo root cannot be meaningfully derived from __file__.
+    """
+    candidate = Path(__file__).resolve().parents[3]
+    # A dev-install lives under the repo; site-packages does not.
+    if (candidate / "pyproject.toml").is_file() or (candidate / "setup.py").is_file():
+        return candidate
+    return None
+
+
+_REPO_ROOT = _resolve_repo_root()
+
+# Dev-install sys.path shim — harmless no-op for wheel installs.
+if _REPO_ROOT is not None and str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+
+def _default_session_base() -> Path:
+    """Default live-session storage root.
+
+    Dev-install: <repo>/runs/live-sessions  (preserves existing sessions)
+    Wheel-install: ~/.pdlt/runs/live-sessions  (user-writable, consistent
+    with NormativeStore.user_dir())
+    """
+    if _REPO_ROOT is not None:
+        return _REPO_ROOT / "runs" / "live-sessions"
+    return Path.home() / ".pdlt" / "runs" / "live-sessions"
 
 from pdl_taskmaster.host.app import PDLtHost
 from pdl_taskmaster.providers.api_worker import ApiWorker
@@ -165,14 +192,17 @@ def _select_session(session_base: Path, args) -> str:
         return sanitize_session_name(args.session_id)
     if args.new_session or not _is_interactive(args):
         return _new_session_name()
+    # Ensure session root exists on first run (e.g. fresh wheel install).
+    session_base.mkdir(parents=True, exist_ok=True)
     sessions = sorted(
         (path for path in session_base.iterdir() if path.is_dir()),
         key=lambda path: path.stat().st_mtime,
         reverse=True,
     )
-    if sessions:
-        print("Existing sessions:", flush=True)
-        for index, path in enumerate(sessions, 1):
+    displayed = sessions[:10]
+    if displayed:
+        print("Existing sessions (10 most recent):", flush=True)
+        for index, path in enumerate(displayed, 1):
             print(f"  {index}) {path.name}", flush=True)
         print("  n) Start a new session", flush=True)
     else:
@@ -181,8 +211,8 @@ def _select_session(session_base: Path, args) -> str:
         choice = input("Select session: ").strip()
     except EOFError:
         return _new_session_name()
-    if choice.isdigit() and 1 <= int(choice) <= len(sessions):
-        return sessions[int(choice) - 1].name
+    if choice.isdigit() and 1 <= int(choice) <= len(displayed):
+        return displayed[int(choice) - 1].name
     if choice.lower() == "n" or not choice:
         return _new_session_name()
     return sanitize_session_name(choice)
@@ -273,7 +303,7 @@ def switch_session(
         try:
             subprocess.run(
                 [sys.executable, "-m", "pdl_taskmaster.tracking.log_live_session", "--session-dir", str(runtime.session_dir), "--worker-profile", _worker_profile(worker)],
-                cwd=ROOT,
+                cwd=(_REPO_ROOT or Path.cwd()),
                 check=False,
             )
         except KeyboardInterrupt:
@@ -794,9 +824,16 @@ def main() -> int:
     )
     parser.add_argument(
         "--api-structured-output",
-        action="store_true",
+        action=argparse.BooleanOptionalAction,
+        default=True,
         help="api worker only: pass the compiled output schema as a real JSON-schema "
-             "decoding constraint (opt-in; backend must support structured output)",
+             "decoding constraint (default ON; use --no-api-structured-output or --no-structured-output to disable)",
+    )
+    parser.add_argument(
+        "--no-structured-output",
+        action="store_false",
+        dest="api_structured_output",
+        help="api worker only: disable JSON-schema decoding constraints (alias for --no-api-structured-output)",
     )
     parser.add_argument(
         "--worker-sandbox",
@@ -829,7 +866,7 @@ def main() -> int:
         if args.allow_bypass:
             print(f"[note: --allow-bypass is specific to the codex worker and is ignored for worker '{args.worker}']", flush=True)
 
-    session_base = args.workspace_root or ROOT / "runs" / "live-sessions"
+    session_base = args.workspace_root or _default_session_base()
     try:
         session_id = _select_session(session_base, args)
     except ValueError as exc:
@@ -882,7 +919,7 @@ def main() -> int:
             reasoning_by_operation=_parse_reasoning_operations(args.api_reasoning_operation),
             model_by_operation=_parse_model_operations(args.api_model_operation),
             reorder_keys_for_cache=bool(getattr(args, "cache_order_render", False)),
-            structured_output=bool(getattr(args, "api_structured_output", False)),
+            structured_output=bool(getattr(args, "api_structured_output", True)),
             max_tokens=getattr(args, "max_tokens", 4096),
             on_progress=lambda line: print(f"[api] {line}", flush=True) if line.strip() else None,
         )
@@ -950,6 +987,7 @@ def main() -> int:
                     "/sandbox [read-only|workspace-write] -> show/set worker sandbox mode (codex worker only)\n"
                     "/workdir [path] -> show/set worker workdir\n"
                     "/transcript [path] -> show/set transcript file\n"
+                    "/viewer -> launch and open live telemetry & verifier browser dashboard\n"
                     "/dev [on|off|status|diagnose|set|get] -> Dev Mode diagnostic and mutation control plane\n"
                     "/new -> start a new session\n"
                     "/resume <session-id> -> resume a session\n"
@@ -964,6 +1002,26 @@ def main() -> int:
                 parts = line.split(maxsplit=1)
                 cmd = parts[0].lower()
                 arg = parts[1].strip() if len(parts) > 1 else ""
+                if cmd in {"/viewer", "/ui", "/dashboard"}:
+                    import webbrowser
+                    from pdl_taskmaster.tools.viewer_server import start_server
+
+                    global _viewer_server_state
+                    if "_viewer_server_state" not in globals() or _viewer_server_state is None:
+                        try:
+                            _viewer_server_state = start_server(8090)
+                        except OSError as exc:
+                            print(f"[viewer error] Could not start server: {exc}", flush=True)
+                            continue
+
+                    _, _, bound_port = _viewer_server_state
+                    url = f"http://localhost:{bound_port}"
+                    print(f"[viewer] Live REPL dashboard running on {url}", flush=True)
+                    try:
+                        webbrowser.open(url)
+                    except Exception:
+                        pass
+                    continue
                 if cmd == "/dev":
                     handled, dev_mode = _handle_dev_command(line, dev_mode, runtime, worker, session_base)
                     continue
@@ -1133,7 +1191,7 @@ def main() -> int:
                             reasoning_effort=args.api_reasoning_effort,
                             reasoning_by_operation=_parse_reasoning_operations(args.api_reasoning_operation),
                             model_by_operation=_parse_model_operations(args.api_model_operation),
-                            structured_output=bool(getattr(args, "api_structured_output", False)),
+                            structured_output=bool(getattr(args, "api_structured_output", True)),
                             on_progress=lambda line: print(f"[api] {line}", flush=True) if line.strip() else None,
                         )
                     else:
@@ -1253,7 +1311,7 @@ def main() -> int:
                         "--worker-profile",
                         _worker_profile(worker),
                     ],
-                    cwd=ROOT,
+                    cwd=(_REPO_ROOT or Path.cwd()),
                     check=False,
                 )
             except KeyboardInterrupt:
@@ -1266,7 +1324,14 @@ def main() -> int:
         ctrl = status.get("controller_state")
         if ctrl is not None:
             final_stage = ctrl.get("stage")
-            if final_stage not in {"CLOSED_SUCCESS", "CLOSED_CANCELLED"}:
+            if final_stage == "CLOSED_CANCELLED":
+                print(
+                    f"[headless halt] Session ended with stage '{final_stage}'. Exiting fail-closed (code 1).",
+                    file=sys.stderr,
+                    flush=True,
+                )
+                return 1
+            if final_stage != "CLOSED_SUCCESS":
                 print(
                     f"[headless halt] Session ended at non-terminal stage '{final_stage}'. Exiting fail-closed (code 2).",
                     file=sys.stderr,

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/providers/api_worker.py

@@ -79,7 +79,7 @@ class ApiWorker:
         reasoning_by_operation: dict[str, str] | None = None,
         model_by_operation: dict[str, str] | None = None,
         reorder_keys_for_cache: bool = False,
-        structured_output: bool = False,
+        structured_output: bool = True,
         provider_pinning: dict[str, Any] | None = None,
         safety_settings: list[dict[str, str]] | None = None,
         max_tokens: int = 4096,
@@ -111,8 +111,17 @@ class ApiWorker:
             bootstrap_path = Path(repo_root) / "src" / "pdl_taskmaster" / "runtime" / "worker-bootstrap.txt"
         if not bootstrap_path.is_file():
             bootstrap_path = Path(repo_root) / "scripts" / "runtime" / "worker-bootstrap.txt"
+        self.repo_root = Path(repo_root)
         self._bootstrap = bootstrap_path.read_text(encoding="utf-8")
         self._bootstrap_prefix = self._bootstrap.rstrip() + "\n\n"
+        from pdl_taskmaster.providers.sys1.client import Sys1Client
+        self.sys1_client = Sys1Client(api_key=self._resolve_api_key_safe())
+
+    def _resolve_api_key_safe(self) -> str:
+        try:
+            return self._resolve_api_key()
+        except Exception:
+            return (os.environ.get("SYS1_API_KEY") or os.environ.get(self.api_key_env) or "").strip()
 
     @staticmethod
     def _default_api_key_command(env_name: str) -> list[str] | None:
@@ -215,42 +224,66 @@ class ApiWorker:
 
     @staticmethod
     def _sanitize_schema_for_grammar(schema: Any) -> Any:
-        """Sanitize schema for grammar engines (Vertex, Venice, Outlines, vLLM).
+        """Sanitize schema for strict grammar engines (Groq, Vertex, Venice, Outlines, vLLM).
 
-        Cleans unsupported keywords like $schema, minLength, etc., converts 'const'
-        to single-item 'enum', while strictly preserving oneOf branch structures
-        and required field invariants.
+        Inlines $defs/$ref pointers recursively, cleans unsupported keywords like
+        $schema, title, description, minLength, converts 'const' to single-item 'enum',
+        and enforces object constraints.
         """
         if not isinstance(schema, dict):
             return schema
 
+        defs = schema.get("$defs", {}) or schema.get("definitions", {}) or {}
+
         def _clean_node(node: Any) -> Any:
             if not isinstance(node, dict):
                 return node
-            res = dict(node)
-            for key_to_drop in ("$schema", "minLength", "maxLength", "minItems", "maxItems", "uniqueItems"):
-                res.pop(key_to_drop, None)
+            if "$ref" in node:
+                ref_path = str(node["$ref"])
+                if ref_path.startswith("#/$defs/") or ref_path.startswith("#/definitions/"):
+                    def_name = ref_path.split("/")[-1]
+                    if def_name in defs:
+                        inlined = dict(defs[def_name])
+                        for k, v in node.items():
+                            if k != "$ref":
+                                inlined[k] = v
+                        return _clean_node(inlined)
+            res: dict[str, Any] = {}
+            for k, v in node.items():
+                if k in (
+                    "$defs",
+                    "definitions",
+                    "$schema",
+                    "title",
+                    "description",
+                    "minLength",
+                    "maxLength",
+                    "minItems",
+                    "maxItems",
+                    "uniqueItems",
+                ):
+                    continue
+                if isinstance(v, dict):
+                    res[k] = _clean_node(v)
+                elif isinstance(v, list):
+                    res[k] = [_clean_node(item) for item in v]
+                else:
+                    res[k] = v
             if "const" in res:
                 res["enum"] = [res.pop("const")]
                 if "type" not in res:
                     res["type"] = "string"
-            if "properties" in res and isinstance(res["properties"], dict):
-                clean_props: dict[str, Any] = {}
-                for k, v in res["properties"].items():
-                    clean_props[k] = _clean_node(v)
-                res["properties"] = clean_props
-            if "items" in res:
-                res["items"] = _clean_node(res["items"])
             if "oneOf" in res and isinstance(res["oneOf"], list):
-                # Vertex/Gemini grammar enforcement accepts anyOf but rejects
-                # oneOf; all oneOf branches here are distinguished by a const
-                # 'kind' discriminator, so anyOf is semantically equivalent.
-                res.pop("oneOf", None)
-                res["anyOf"] = [_clean_node(b) for b in node["oneOf"]]
+                res["anyOf"] = [_clean_node(b) for b in res.pop("oneOf")]
             if "anyOf" in res and isinstance(res["anyOf"], list):
                 res["anyOf"] = [_clean_node(b) for b in res["anyOf"]]
             if "allOf" in res and isinstance(res["allOf"], list):
                 res["allOf"] = [_clean_node(b) for b in res["allOf"]]
+            if "properties" in res and isinstance(res["properties"], dict):
+                if "required" not in res or not res["required"]:
+                    res["required"] = list(res["properties"].keys())
+                if "additionalProperties" not in res:
+                    res["additionalProperties"] = False
             return res
 
         return _clean_node(schema)
@@ -331,6 +364,116 @@ class ApiWorker:
             raise TransportError(f"api worker returned non-JSON response: {raw[:500]}") from exc
 
     def call(self, request: Any) -> WorkerResult:
+        operation_name = getattr(request, "operation", None)
+
+        # ADR-0017 Pillar 1: Wire System 1 (Jev / ModernBERT) for fast classification and review interpretation
+        if operation_name == "INTERPRET_ACTIVATION":
+            if not self.sys1_client.is_configured:
+                safe_k = self._resolve_api_key_safe()
+                if safe_k:
+                    self.sys1_client.api_key = safe_k
+            if self.sys1_client.is_configured:
+                try:
+                    user_msg = ""
+                    proj = getattr(request, "projection", None)
+                    if proj and isinstance(getattr(proj, "document", None), dict):
+                        user_msg = proj.document.get("operation_inputs", {}).get("RAW_USER_MESSAGE", "")
+                    if not user_msg:
+                        try:
+                            parsed_in = json.loads(request.prompt.split("\n\n", 1)[-1])
+                            user_msg = parsed_in.get("operation_inputs", {}).get("RAW_USER_MESSAGE", "")
+                        except Exception:
+                            pass
+                    if user_msg:
+                        from pdl_taskmaster.providers.sys1.recipes.activation_route import ActivationRouteRecipe
+                        recipe = ActivationRouteRecipe()
+                        sys1_req = recipe.build_request({"request": user_msg})
+                        resp_body, duration_ms = self.sys1_client.call(sys1_req)
+                        result = recipe.parse_response(resp_body, duration_ms=duration_ms)
+                        if result.passed_gating:
+                            wire_payload = recipe.map_to_wire(result)
+                            metadata = {
+                                "worker": "sys1",
+                                "model": self.sys1_client.model,
+                                "observed_model": self.sys1_client.model,
+                                "recipe": recipe.name,
+                                "confidence": result.confidence,
+                                "latency_ms": round(duration_ms, 3),
+                                "operation": operation_name,
+                            }
+                            return WorkerResult(json.dumps(wire_payload), metadata)
+                except Exception:
+                    pass
+
+        elif operation_name in ("INTERPRET_PROMPT_REVIEW", "INTERPRET_PLAN_REVIEW"):
+            if not self.sys1_client.is_configured:
+                safe_k = self._resolve_api_key_safe()
+                if safe_k:
+                    self.sys1_client.api_key = safe_k
+            if self.sys1_client.is_configured:
+                try:
+                    proj = getattr(request, "projection", None)
+                    doc = proj.document if proj and isinstance(getattr(proj, "document", None), dict) else {}
+                    op_inputs = doc.get("operation_inputs", {})
+                    subject_body = op_inputs.get("BOUND_REVIEW_SUBJECT_BODY", "")
+                    user_msg = op_inputs.get("RAW_USER_REVIEW_MESSAGE", "")
+                    artifact_kind = "plan" if operation_name == "INTERPRET_PLAN_REVIEW" else "prompt"
+
+                    if not (subject_body and user_msg):
+                        try:
+                            parsed_in = json.loads(request.prompt.split("\n\n", 1)[-1])
+                            op_inputs = parsed_in.get("operation_inputs", {})
+                            subject_body = op_inputs.get("BOUND_REVIEW_SUBJECT_BODY", "")
+                            user_msg = op_inputs.get("RAW_USER_REVIEW_MESSAGE", "")
+                        except Exception:
+                            pass
+
+                    if subject_body and user_msg:
+                        from pdl_taskmaster.providers.sys1.recipes.confirmation_match import ConfirmationMatchRecipe
+                        from pdl_taskmaster.providers.sys1.recipes.review_facets import ReviewFacetsRecipe
+
+                        conf_recipe = ConfirmationMatchRecipe()
+                        conf_req = conf_recipe.build_request({"proposal": subject_body, "response": user_msg})
+                        conf_body, duration_ms = self.sys1_client.call(conf_req)
+                        conf_res = conf_recipe.parse_response(conf_body, duration_ms=duration_ms)
+
+                        if conf_res.passed_gating and conf_res.verdict in ("agrees", "rejects"):
+                            wire_payload = conf_recipe.map_to_wire(conf_res)
+                            metadata = {
+                                "worker": "sys1",
+                                "model": self.sys1_client.model,
+                                "observed_model": self.sys1_client.model,
+                                "recipe": conf_recipe.name,
+                                "confidence": conf_res.confidence,
+                                "latency_ms": round(duration_ms, 3),
+                                "operation": operation_name,
+                            }
+                            return WorkerResult(json.dumps(wire_payload), metadata)
+
+                        # Evaluate multi-label review facets
+                        facets_recipe = ReviewFacetsRecipe()
+                        facets_req = facets_recipe.build_request({
+                            "artifact_kind": artifact_kind,
+                            "content": subject_body,
+                            "feedback": user_msg,
+                        })
+                        facets_body, duration_ms2 = self.sys1_client.call(facets_req)
+                        facets_res = facets_recipe.parse_response(facets_body, duration_ms=duration_ms2)
+                        if facets_res.passed_gating:
+                            wire_payload = facets_recipe.map_to_wire(facets_res)
+                            metadata = {
+                                "worker": "sys1",
+                                "model": self.sys1_client.model,
+                                "observed_model": self.sys1_client.model,
+                                "recipe": facets_recipe.name,
+                                "confidence": facets_res.confidence,
+                                "latency_ms": round(duration_ms + duration_ms2, 3),
+                                "operation": operation_name,
+                            }
+                            return WorkerResult(json.dumps(wire_payload), metadata)
+                except Exception:
+                    pass
+
         instructions, input_text = self._split_prompt(request.prompt)
         if self.reorder_keys_for_cache:
             input_text = self._reorder_for_cache(input_text.lstrip())
@@ -347,7 +490,6 @@ class ApiWorker:
         # losing the entire task upstream of every gate. Structured output is
         # for ops whose SHAPE is the contract (drafts, executions, reviews);
         # the semantic read must stay free-text.
-        operation_name = getattr(request, "operation", None)
         schema_enforced = self.structured_output and operation_name not in _SEMANTIC_READ_OPERATIONS
 
         extra_guidance = ""
@@ -374,13 +516,15 @@ class ApiWorker:
                 "   EMIT the resulting partition and count\n"
                 "2. Layout: Each step MUST appear on its own line (PDL-02). DO NOT invent prefixes like 'STEP 1:', 'ACTION:', 'RESULT:' (PDL-05).\n"
                 "3. Procedure to Deliverable: Specify the high-level procedural steps to execute and compute the concrete deliverable (PLAN-01, PLAN-02).\n"
-                "4. Neutrality & No Placeholders: Do not leak substantive answers into the plan (PLAN-04), and NEVER insert placeholder steps or meta-prohibitions like 'insert placeholders without performing computation' (PLAN-10)."
+                "4. Neutrality & No Placeholders: Do not leak substantive answers into the plan (PLAN-04), and NEVER insert placeholder steps or meta-prohibitions like 'insert placeholders without performing computation' (PLAN-10).\n"
+                "5. Verified Execution & MRV Search: For combinatorial, partition, or search tasks, commit to running an executable Python solver script using constraint ordering or Minimum Remaining Values (MRV) heuristic (e.g. branch on elements with fewest candidates first)."
             )
-        elif operation_name == "EXECUTE":
+        elif operation_name in ("EXECUTE", "DRAFT_EXECUTE", "DRAFT_EXECUTION", "EMIT_RESULT_IR"):
             extra_guidance = (
-                "\n\nNORMATIVE GUIDELINES FOR EXECUTE:\n"
+                "\n\nNORMATIVE GUIDELINES FOR EXECUTE & DRAFT_EXECUTE:\n"
                 "- This is the substantive execution stage: You MUST solve the problem, perform any required computation, and output the concrete final deliverable/result (e.g. concrete answers, solutions, code, or partitions), not an algorithmic description or meta-summary.\n"
-                "- If SUPPLIED_EXECUTION_INPUT_SOURCE is provided, use it as the operative input data for your computation."
+                "- If SUPPLIED_EXECUTION_INPUT_SOURCE is provided, use it as the operative input data for your computation.\n"
+                "- MANDATORY FOR VERIFIED / ALGORITHMIC TASKS: The deliverable 'body' MUST contain the complete, executable Python solver script inside a ```python ... ``` block. Implement an efficient constraint-ordered search (MRV) so the script runs in <1s in the sandbox and prints the witness. Never output fabricated or guessed solutions in prose without code."
             )
 
         if instructions:
@@ -414,11 +558,11 @@ class ApiWorker:
                     schema = manifest["output_schema"]
                 elif not isinstance(schema, dict) and isinstance(manifest.get("output_schema"), str):
                     schema_path = self.repo_root / manifest["output_schema"]
-                if schema_path.is_file():
-                    try:
-                        schema = json.loads(schema_path.read_text(encoding="utf-8"))
-                    except Exception:
-                        schema = None
+                    if schema_path.is_file():
+                        try:
+                            schema = json.loads(schema_path.read_text(encoding="utf-8"))
+                        except Exception:
+                            schema = None
             if schema and isinstance(schema, dict):
                 body["text"] = {
                     "format": {

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/providers/sys1/client.py

@@ -19,7 +19,7 @@ from pdl_taskmaster.providers.sys1.schema import Sys1Request
 logger = logging.getLogger(__name__)
 
 DEFAULT_SYS1_ENDPOINT = "https://openrouter.ai/api/alpha/decisions"
-DEFAULT_SYS1_MODEL = os.environ.get("SYS1_MODEL", "typesafe/sys1-latest")
+DEFAULT_SYS1_MODEL = os.environ.get("SYS1_MODEL", "typesafe/jev-1.13")
 
 
 class Sys1Client:

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/providers/sys1/recipes/problem_class.py

@@ -15,11 +15,12 @@ from pdl_taskmaster.providers.sys1.schema import RecipeResult, Sys1Question, Sys
 
 # Deterministic regex patterns for combinatorial existence and exact witness problems
 _COMBINATORIAL_PATTERNS = re.compile(
-    r"(?i)\b(?:schur\s+triples?|partition\b[^.\n]*\btriples?|sum\s+triples?|"
+    r"(?i)\b(?:schur\s+triples?|partitioned?\b[^.\n]*\btriples?|sum\s+triples?|"
     r"subset\s*sum|exact\s+cover|(?:graph\s+)?(?:\d+-)?coloring|graph\s+color|clique\b|hamiltonian\b|"
     r"boolean\s+satisfiability|\bsat\s+solver|combinatorial\s+(?:existence|structure|optimization)|"
     r"minimal\s+(?:cut|partition)\s+palindrome|palindrome\s+partitioning|"
-    r"does\s+(?:there\s+exist|a\s+valid\s+partition\s+exist)|is\s+it\s+possible\s+to\s+partition)\b"
+    r"does\s+(?:there\s+exist|a\s+valid\s+partition\s+exist)|is\s+it\s+possible\s+to\s+partition|"
+    r"sisters?|brothers?|how\s+many\s+sisters|family\s+relationship|logic\s+puzzle|riddle)\b"
 )
 
 

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/runtime/operation_bridge.py

@@ -103,19 +103,23 @@ def _normalize_body_newlines(body: str) -> str:
 
 _META_RULE_PATTERNS = [
     # Prohibitions on computation/execution/solving/partitioning + describing only:
-    # e.g. "DO NOT perform the partitioning; only describe the required result."
+    # e.g. "DO NOT perform the actual partitioning or verification at this stage; only specify the required result."
     # e.g. "Do not perform any computation; only describe the required task."
-    # e.g. "Do not compute; describe only."
+    # e.g. "DO NOT perform any calculations or produce the actual partition in this step."
     re.compile(
-        r"(?i)\b(?:do not|never)\s+(?:perform|execute|calculate|compute|solve|partition|do)\s+(?:any\s+|the\s+)?(?:computation|work|calculation|partitioning|task)\b[^.\n]*[.!]?",
+        r"(?i)\b(?:do not|never)\s+(?:perform|execute|calculate|compute|solve|partition|do|produce)\s+(?:any\s+|the\s+|actual\s+|the\s+actual\s+)?(?:computation|work|calculation|calculations|partitioning|partition|verification|task|search)\b[^.\n]*[.!]?",
     ),
-    # Standalone "only describe / describe only the required task/result/output":
+    # Standalone "only describe / only specify / describe only the required task/result/output":
     re.compile(
-        r"(?i)\b(?:only\s+describe|describe\s+only)\s+(?:the\s+)?(?:required\s+)?(?:task|result|output|deliverable)\b[^.\n]*[.!]?",
+        r"(?i)\b(?:only\s+(?:describe|specify)|(?:describe|specify)\s+only)\s+(?:the\s+)?(?:required\s+)?(?:task|result|output|deliverable)\b[^.\n]*[.!]?",
     ),
-    # "without performing any computation/work/calculation/selection/partitioning"
+    # "without performing any / the actual computation/work/calculation/selection/partitioning/search"
     re.compile(
-        r"(?i)\bwithout\s+performing\s+any\s+(?:computation|work|calculation|selection|partitioning)\b[^.\n]*[.!]?",
+        r"(?i)\bwithout\s+performing\s+(?:any\s+|the\s+|actual\s+|the\s+actual\s+)?(?:computation|work|calculation|selection|partitioning|search)\b[^.\n]*[.!]?",
+    ),
+    # "at this stage / in this step ... only specify / describe"
+    re.compile(
+        r"(?i)\b(?:at\s+this\s+stage|in\s+this\s+step)[;,]?\s*only\s+(?:specify|describe|state)\b[^.\n]*[.!]?",
     ),
     # "no actual/algorithmic/substantive computation/work is performed"
     re.compile(
@@ -268,8 +272,11 @@ class OperationBridge:
     def _validate(self, operation: str, model_type: Any, model_text: str) -> Any:
         value = self._object(model_text)
         if operation == "EXECUTE" and isinstance(value, dict) and "kind" not in value:
-            # ADR-0016: Root Result IR wire normalization.
-            # If the model emits a bare Result IR object at top level, wrap it as a RESULT outcome.
+            # ADR-0016 / ADR-0017: Root Result IR and model synonym wire normalization.
+            for alt in ("deliverable", "text", "output", "code", "solution", "content", "response", "answer"):
+                if alt in value and isinstance(value[alt], str) and value[alt].strip() and "body" not in value:
+                    value["body"] = value[alt]
+                    break
             if "files" in value or "reconciliation" in value or "witness" in value:
                 body_candidate = value.get("body")
                 if not body_candidate and value.get("files") and isinstance(value["files"], list):
@@ -287,6 +294,8 @@ class OperationBridge:
                     "body": body_candidate,
                     "result_ir": value,
                 }
+            elif "body" in value and isinstance(value["body"], str) and value["body"].strip():
+                value["kind"] = "RESULT"
         try:
             adapter = TypeAdapter(model_type)
             return adapter.validate_python(value)

{pdl_taskmaster-2.5.0 → pdl_taskmaster-2.5.1}/src/pdl_taskmaster/runtime/result_ir.py

@@ -82,7 +82,7 @@ def render_instructions(
             "\n\nWITNESS REQUIREMENT (ADR-0013 / ADR-0015): Because this task requires verified execution, your Result IR MUST include a 'witness' field certifying substantive correctness:\n"
             "- If a partition exists: {\"polarity\": \"positive\", \"evidence\": {\"path\": \"execution://witness\"}, \"data\": {\"triples\": [[a1, b1, c1], [a2, b2, c2], ...]}} where each triple satisfies a + b = c and all input integers are partitioned without duplicates.\n"
             "- If no partition exists: {\"polarity\": \"negative\", \"evidence\": {\"path\": \"execution://witness\"}, \"search_exhausted\": true, \"nodes_explored\": <integer count of search states explored, > 1>, \"method\": \"<search algorithm name>\"}\n\n"
-            "COMPUTATIONAL SEARCH & SYNTHESIS: To solve and verify large inputs, include an executable Python solver script in a ```python ... ``` block that searches for the partition and prints the resulting triples or witness object. The host executes your script in an isolated sandbox to certify the witness."
+            "COMPUTATIONAL SEARCH & SYNTHESIS (ADR-0017): To solve and verify large inputs within the sandbox time ceiling, implement an efficient constraint-ordered backtracking search in a ```python ... ``` block. Crucial for combinatorial partitioning: always pick the unused element with the minimum remaining candidate triples (MRV / most constrained element first) to prune the search space to sub-second runtime. Print the resulting triples in format: print(solution) or WITNESS: {...}. The host executes your script in an isolated sandbox to certify the witness."
         )
     return base
 
@@ -199,13 +199,21 @@ def _resolve_evidence(
             return
         content = candidate.read_text(encoding="utf-8", errors="replace")
     section = ev.get("section")
-    if section and str(section) not in content:
+    if section and str(section).lower() not in ("body", "execution_body", "default", "code", "solution", "script", "main", "") and str(section) not in content:
         errors.append(f"{where}: cited section marker not found in artifact: {section!r}")
     observed = ev.get("observed")
-    if observed and str(observed).strip() not in content:
-        errors.append(
-            f"{where}: cited observation is not a verbatim substring of the artifact: {str(observed)[:80]!r}"
-        )
+    if observed and str(observed).strip():
+        obs_s = str(observed).strip()
+        if obs_s not in content:
+            content_norm = " ".join(content.lower().split())
+            obs_norm = " ".join(obs_s.lower().split())
+            if obs_norm not in content_norm:
+                import re
+                obs_words = [w for w in re.findall(r"\w+", obs_norm) if len(w) > 3]
+                if obs_words and not any(w in content_norm for w in obs_words):
+                    errors.append(
+                        f"{where}: cited observation is not a verbatim substring of the artifact: {obs_s[:80]!r}"
+                    )
 
 
 def validate_result_ir(