polydeukes-sdk 0.19.1__tar.gz

polydeukes_sdk-0.19.1/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+*.pyc
+.ruff_cache/
+dist/
+*.egg-info/

polydeukes_sdk-0.19.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hyung Soo Seung
+
+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.

polydeukes_sdk-0.19.1/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.5
+Name: polydeukes-sdk
+Version: 0.19.1
+Summary: Call the Polydeukes covenant and memory commands from Python
+Project-URL: Repository, https://github.com/huskyhoochu/polydeukes
+Project-URL: Documentation, https://polydeukes.vercel.app
+Author: Polydeukes contributors
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# `polydeukes-sdk` (Python)
+
+**English** · [한국어](README.ko.md)
+
+Call the Polydeukes judge and memory commands from Python 3.12 or newer. Four synchronous
+verbs share one executable resolver and process runner. The package has zero runtime dependencies.
+
+```sh
+python -m pip install polydeukes-sdk
+```
+
+Download `pdks-linux-x64` or `pdks-darwin-arm64` from a
+[GitHub Release](https://github.com/huskyhoochu/polydeukes/releases), mark it executable, and
+put it on an absolute `PATH` directory as `pdks`, or pass its path as `executable`.
+Keep the SDK and executable on the same minor release. These are the supported platforms:
+Linux x64 and macOS arm64. On macOS, a browser download may require
+`xattr -d com.apple.quarantine /path/to/pdks`.
+
+```python
+from polydeukes_sdk import (
+    CheckCovenantSpec,
+    CovenantInput,
+    Upheld,
+    check_covenant,
+    CheckChangeSetSpec,
+    check_change_set,
+    MemoryIngestSpec,
+    memory_ingest,
+    MemorySearchSpec,
+    memory_search,
+    Found,
+    Empty,
+    Unavailable,
+)
+
+payload: CovenantInput = {"toolCalls": [], "subagentSpawns": [], "userMessages": []}
+verdict = check_covenant(CheckCovenantSpec(repo_root=".", input=payload, timeout=10))
+if isinstance(verdict, Upheld):
+    print("The proposed operation may proceed", verdict.advisories)
+
+verdict = check_change_set(CheckChangeSetSpec(repo_root=".", diff="", timeout=10))
+ingest = memory_ingest(MemoryIngestSpec(root=".", timeout=30))
+recall = memory_search(MemorySearchSpec(root=".", query="design decision", limit=5, timeout=10))
+match recall:
+    case Found(hits=hits):
+        print(hits[0]["sectionTitle"])
+    case Empty():
+        print("No matches")
+    case Unavailable(reason=reason):
+        print("Memory unavailable:", reason)
+```
+
+The host supplies IR evidence and decides whether to execute the proposed operation. Only
+`Upheld` permits it in this example. The child reads configuration, judges disciplines, writes
+telemetry, and manages the memory index.
+
+The [Python SDK reference](https://github.com/huskyhoochu/polydeukes/blob/main/docs/reference/packages/sdk-python.md)
+describes every spec, outcome, timeout, and the injectable `spawn` boundary.

polydeukes_sdk-0.19.1/README.ko.md

@@ -0,0 +1,57 @@
+# `polydeukes-sdk` (Python)
+
+[English](README.md) · **한국어**
+
+Python 3.12 이상에서 Polydeukes 판정기와 기억(memory) 명령을 호출합니다. 동기 동사 네 개가
+실행 파일 해석기와 프로세스 실행기 하나를 공유합니다. 런타임 의존성은 없습니다.
+
+```sh
+python -m pip install polydeukes-sdk
+```
+
+[GitHub Release](https://github.com/huskyhoochu/polydeukes/releases)에서 `pdks-linux-x64` 또는
+`pdks-darwin-arm64`를 받아 실행 권한을 부여하고, 절대 `PATH` 디렉터리에 `pdks`라는 이름으로
+두거나 `executable`에 경로를 지정합니다. SDK와 실행 파일의 minor 버전을 맞춥니다. 지원 플랫폼은
+Linux x64와 macOS arm64입니다. macOS에서 브라우저로 받았다면
+`xattr -d com.apple.quarantine /path/to/pdks`가 필요할 수 있습니다.
+
+```python
+from polydeukes_sdk import (
+    CheckCovenantSpec,
+    CovenantInput,
+    Upheld,
+    check_covenant,
+    CheckChangeSetSpec,
+    check_change_set,
+    MemoryIngestSpec,
+    memory_ingest,
+    MemorySearchSpec,
+    memory_search,
+    Found,
+    Empty,
+    Unavailable,
+)
+
+payload: CovenantInput = {"toolCalls": [], "subagentSpawns": [], "userMessages": []}
+verdict = check_covenant(CheckCovenantSpec(repo_root=".", input=payload, timeout=10))
+if isinstance(verdict, Upheld):
+    print("제안한 작업을 진행할 수 있습니다", verdict.advisories)
+
+verdict = check_change_set(CheckChangeSetSpec(repo_root=".", diff="", timeout=10))
+ingest = memory_ingest(MemoryIngestSpec(root=".", timeout=30))
+recall = memory_search(MemorySearchSpec(root=".", query="설계 결정", limit=5, timeout=10))
+match recall:
+    case Found(hits=hits):
+        print(hits[0]["sectionTitle"])
+    case Empty():
+        print("검색 결과 없음")
+    case Unavailable(reason=reason):
+        print("기억을 사용할 수 없음:", reason)
+```
+
+호스트는 IR 증거를 제공하고 제안한 작업의 실행 여부를 결정합니다. 이 예시는 `Upheld`일 때만
+실행을 허용합니다. 자식 프로세스가 설정을 읽고 규율(discipline)을 판정하며 텔레메트리와 기억
+색인을 관리합니다.
+
+[Python SDK 참조](https://github.com/huskyhoochu/polydeukes/blob/main/docs/reference/packages/sdk-python.ko.md)에서
+모든 spec, 결과, 기한과 주입 가능한 `spawn` 경계를 설명합니다.

polydeukes_sdk-0.19.1/README.md

@@ -0,0 +1,58 @@
+# `polydeukes-sdk` (Python)
+
+**English** · [한국어](README.ko.md)
+
+Call the Polydeukes judge and memory commands from Python 3.12 or newer. Four synchronous
+verbs share one executable resolver and process runner. The package has zero runtime dependencies.
+
+```sh
+python -m pip install polydeukes-sdk
+```
+
+Download `pdks-linux-x64` or `pdks-darwin-arm64` from a
+[GitHub Release](https://github.com/huskyhoochu/polydeukes/releases), mark it executable, and
+put it on an absolute `PATH` directory as `pdks`, or pass its path as `executable`.
+Keep the SDK and executable on the same minor release. These are the supported platforms:
+Linux x64 and macOS arm64. On macOS, a browser download may require
+`xattr -d com.apple.quarantine /path/to/pdks`.
+
+```python
+from polydeukes_sdk import (
+    CheckCovenantSpec,
+    CovenantInput,
+    Upheld,
+    check_covenant,
+    CheckChangeSetSpec,
+    check_change_set,
+    MemoryIngestSpec,
+    memory_ingest,
+    MemorySearchSpec,
+    memory_search,
+    Found,
+    Empty,
+    Unavailable,
+)
+
+payload: CovenantInput = {"toolCalls": [], "subagentSpawns": [], "userMessages": []}
+verdict = check_covenant(CheckCovenantSpec(repo_root=".", input=payload, timeout=10))
+if isinstance(verdict, Upheld):
+    print("The proposed operation may proceed", verdict.advisories)
+
+verdict = check_change_set(CheckChangeSetSpec(repo_root=".", diff="", timeout=10))
+ingest = memory_ingest(MemoryIngestSpec(root=".", timeout=30))
+recall = memory_search(MemorySearchSpec(root=".", query="design decision", limit=5, timeout=10))
+match recall:
+    case Found(hits=hits):
+        print(hits[0]["sectionTitle"])
+    case Empty():
+        print("No matches")
+    case Unavailable(reason=reason):
+        print("Memory unavailable:", reason)
+```
+
+The host supplies IR evidence and decides whether to execute the proposed operation. Only
+`Upheld` permits it in this example. The child reads configuration, judges disciplines, writes
+telemetry, and manages the memory index.
+
+The [Python SDK reference](https://github.com/huskyhoochu/polydeukes/blob/main/docs/reference/packages/sdk-python.md)
+describes every spec, outcome, timeout, and the injectable `spawn` boundary.

polydeukes_sdk-0.19.1/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["hatchling==1.32.4"]
+build-backend = "hatchling.build"
+
+[project]
+name = "polydeukes-sdk"
+version = "0.19.1"
+description = "Call the Polydeukes covenant and memory commands from Python"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Polydeukes contributors"}]
+dependencies = []
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.14",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Repository = "https://github.com/huskyhoochu/polydeukes"
+Documentation = "https://polydeukes.vercel.app"
+
+[dependency-groups]
+dev = [
+  "datamodel-code-generator==0.86.0",
+  "pyright==1.1.414",
+  "ruff==0.17.1",
+  "build==1.6.1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/polydeukes_sdk"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/", "README.md", "README.ko.md", "LICENSE", "pyproject.toml"]
+
+[tool.pyright]
+include = ["src", "tests/typing/valid.py"]
+extraPaths = ["src"]
+pythonVersion = "3.12"
+typeCheckingMode = "strict"
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+exclude = ["src/polydeukes_sdk/ir.py", "src/polydeukes_sdk/memory.py"]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true

polydeukes_sdk-0.19.1/src/polydeukes_sdk/__init__.py

@@ -0,0 +1,49 @@
+"""Typed synchronous clients for a standalone pdks executable."""
+
+from ._api import (
+    check_change_set as check_change_set,
+    check_covenant as check_covenant,
+    memory_ingest as memory_ingest,
+    memory_search as memory_search,
+)
+from ._contract import (
+    Blocked as Blocked,
+    CheckChangeSetSpec as CheckChangeSetSpec,
+    CheckCovenantSpec as CheckCovenantSpec,
+    CheckCovenantVerdict as CheckCovenantVerdict,
+    Empty as Empty,
+    Enforce as Enforce,
+    Found as Found,
+    Ingested as Ingested,
+    MemoryIngestOutcome as MemoryIngestOutcome,
+    MemoryIngestSpec as MemoryIngestSpec,
+    MemorySearchOutcome as MemorySearchOutcome,
+    MemorySearchSpec as MemorySearchSpec,
+    Path as Path,
+    Spawn as Spawn,
+    SpawnOutcome as SpawnOutcome,
+    SpawnSpec as SpawnSpec,
+    Unavailable as Unavailable,
+    Unjudged as Unjudged,
+    Upheld as Upheld,
+)
+from .ir import (
+    Actor as Actor,
+    Channels as Channels,
+    CovenantInput as CovenantInput,
+    FileChange as FileChange,
+    FileChangeCreate as FileChangeCreate,
+    FileChangeDelete as FileChangeDelete,
+    FileChangeModify as FileChangeModify,
+    Session as Session,
+    SessionToolCall as SessionToolCall,
+    SessionUserMessage as SessionUserMessage,
+    SubagentSpawn as SubagentSpawn,
+    ToolCall as ToolCall,
+    Tools as Tools,
+    UserMessage as UserMessage,
+)
+from .memory import (
+    MemorySearchOutput as MemorySearchOutput,
+    MemorySearchResult as MemorySearchResult,
+)

polydeukes_sdk-0.19.1/src/polydeukes_sdk/_api.py

@@ -0,0 +1,131 @@
+"""Four synchronous process clients for the pdks executable."""
+
+import json
+import os
+from typing import cast
+
+from ._contract import (
+    Blocked,
+    CheckChangeSetSpec,
+    CheckCovenantSpec,
+    CheckCovenantVerdict,
+    Empty,
+    Found,
+    Ingested,
+    MemoryIngestOutcome,
+    MemoryIngestSpec,
+    MemorySearchOutcome,
+    MemorySearchSpec,
+    SpawnOutcome,
+    Unavailable,
+    Unjudged,
+    Upheld,
+)
+from ._process import run
+from .memory import MemorySearchResult
+
+
+def _reason(error: Exception) -> str:
+    return str(error) or type(error).__name__
+
+
+def _failure(outcome: SpawnOutcome) -> str:
+    return outcome.stderr.decode("utf-8", errors="replace") or (
+        f"pdks exited with status {outcome.status}"
+    )
+
+
+def _check(spec: CheckCovenantSpec | CheckChangeSetSpec) -> CheckCovenantVerdict:
+    try:
+        args = ("covenant", "check")
+        if isinstance(spec, CheckChangeSetSpec):
+            args += ("--diff",)
+            stdin = spec.diff.encode("utf-8")
+        else:
+            stdin = json.dumps(spec.input, ensure_ascii=False, allow_nan=False).encode("utf-8")
+        args += ("--enforce", spec.enforce)
+        if spec.config_layer is not None:
+            args += ("--config-layer", os.fspath(spec.config_layer))
+        if spec.telemetry_path is not None:
+            args += ("--telemetry-path", os.fspath(spec.telemetry_path))
+        outcome = run(spec.repo_root, spec.executable, spec.timeout, spec.spawn, args, stdin)
+        if outcome.status == 0:
+            return Upheld(outcome.stderr.decode("utf-8"))
+        if outcome.status == 2:
+            return Blocked(outcome.stderr.decode("utf-8"))
+        return Unjudged(_failure(outcome))
+    except Exception as error:
+        return Unjudged(_reason(error))
+
+
+def check_covenant(spec: CheckCovenantSpec) -> CheckCovenantVerdict:
+    """Check caller-provided IR; only Upheld authorizes the proposed action."""
+    return _check(spec)
+
+
+def check_change_set(spec: CheckChangeSetSpec) -> CheckCovenantVerdict:
+    """Check a unified diff without changing its content or line endings."""
+    return _check(spec)
+
+
+def memory_ingest(spec: MemoryIngestSpec) -> MemoryIngestOutcome:
+    """Ingest through pdks, returning Unavailable for every process failure."""
+    try:
+        outcome = run(
+            spec.root, spec.executable, spec.timeout, spec.spawn, ("memory", "ingest"), b""
+        )
+        return Ingested() if outcome.status == 0 else Unavailable(_failure(outcome))
+    except Exception as error:
+        return Unavailable(_reason(error))
+
+
+def _invalid_constant(value: str) -> object:
+    raise ValueError(f"Invalid JSON constant: {value}")
+
+
+def _hits(data: bytes) -> tuple[MemorySearchResult, ...]:
+    payload: object = json.loads(data.decode("utf-8"), parse_constant=_invalid_constant)
+    if not isinstance(payload, dict):
+        raise ValueError("memory search response must be an object")
+    root = cast(dict[str, object], payload)
+    results = root.get("results")
+    if not isinstance(root.get("ingestedAt"), str) or not isinstance(results, list):
+        raise ValueError("memory search response requires ingestedAt and results")
+    for value in cast(list[object], results):
+        if not isinstance(value, dict):
+            raise ValueError("memory search hit must be an object")
+        hit = cast(dict[str, object], value)
+        if not all(
+            isinstance(hit.get(field), str)
+            for field in ("id", "conceptId", "docTitle", "sectionTitle", "status")
+        ):
+            raise ValueError("memory search hit requires string identity and status fields")
+        if hit.get("trust") not in ("human-reviewed", "machine-verified", "unverified"):
+            raise ValueError("memory search hit has invalid trust")
+        if hit.get("matchPath") not in ("and", "or", "like"):
+            raise ValueError("memory search hit has invalid matchPath")
+        superseded = hit.get("supersededBy")
+        if (
+            not isinstance(hit.get("stale"), bool)
+            or not isinstance(superseded, list)
+            or not all(isinstance(item, str) for item in cast(list[object], superseded))
+        ):
+            raise ValueError("memory search hit requires stale and supersededBy")
+    return tuple(cast(list[MemorySearchResult], results))
+
+
+def memory_search(spec: MemorySearchSpec) -> MemorySearchOutcome:
+    """Return ranked hits, a valid empty search, or an unavailable response."""
+    try:
+        args = ("memory", "search", spec.query, "--json")
+        if spec.limit is not None:
+            if type(spec.limit) is not int or spec.limit <= 0:
+                raise ValueError("limit must be a positive integer")
+            args += ("--limit", str(spec.limit))
+        outcome = run(spec.root, spec.executable, spec.timeout, spec.spawn, args, b"")
+        if outcome.status != 0:
+            return Unavailable(_failure(outcome))
+        hits = _hits(outcome.stdout)
+        return Found(hits) if hits else Empty()
+    except Exception as error:
+        return Unavailable(_reason(error))

polydeukes_sdk-0.19.1/src/polydeukes_sdk/_contract.py

@@ -0,0 +1,135 @@
+"""Immutable call specifications and result variants."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from os import PathLike
+from typing import Literal
+
+from .ir import CovenantInput
+from .memory import MemorySearchResult
+
+type Path = str | PathLike[str]
+type Enforce = Literal["advise", "block"]
+
+
+@dataclass(frozen=True, kw_only=True)
+class SpawnSpec:
+    """One direct executable invocation; an injected spawn enforces its timeout."""
+
+    command: str
+    args: tuple[str, ...]
+    cwd: str
+    stdin: bytes
+    timeout: float | None
+
+
+@dataclass(frozen=True, kw_only=True)
+class SpawnOutcome:
+    """Captured process output, with a missing status representing a signal."""
+
+    status: int | None
+    stdout: bytes
+    stderr: bytes
+
+
+type Spawn = Callable[[SpawnSpec], SpawnOutcome]
+
+
+@dataclass(frozen=True, kw_only=True)
+class CheckCovenantSpec:
+    """Check a caller-built input in the repository root."""
+
+    repo_root: Path
+    input: CovenantInput
+    enforce: Enforce = "block"
+    config_layer: Path | None = None
+    telemetry_path: Path | None = None
+    executable: Path | None = None
+    timeout: float | None = None
+    spawn: Spawn | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class CheckChangeSetSpec:
+    """Check the exact UTF-8 bytes of a caller's unified diff."""
+
+    repo_root: Path
+    diff: str
+    enforce: Enforce = "block"
+    config_layer: Path | None = None
+    telemetry_path: Path | None = None
+    executable: Path | None = None
+    timeout: float | None = None
+    spawn: Spawn | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class MemoryIngestSpec:
+    """Ask the executable to ingest documents under root."""
+
+    root: Path
+    executable: Path | None = None
+    timeout: float | None = None
+    spawn: Spawn | None = None
+
+
+@dataclass(frozen=True, kw_only=True)
+class MemorySearchSpec:
+    """Search the executable's memory index with one literal query argument."""
+
+    root: Path
+    query: str
+    limit: int | None = None
+    executable: Path | None = None
+    timeout: float | None = None
+    spawn: Spawn | None = None
+
+
+@dataclass(frozen=True)
+class Upheld:
+    """The executable upheld the covenant, possibly with advisories."""
+
+    advisories: str
+
+
+@dataclass(frozen=True)
+class Blocked:
+    """The covenant command returned its blocking exit status."""
+
+    reason: str
+
+
+@dataclass(frozen=True)
+class Unjudged:
+    """No covenant verdict was available."""
+
+    reason: str
+
+
+@dataclass(frozen=True)
+class Ingested:
+    """The memory ingest command succeeded."""
+
+
+@dataclass(frozen=True)
+class Unavailable:
+    """The memory command or its response could not be consumed."""
+
+    reason: str
+
+
+@dataclass(frozen=True)
+class Found:
+    """Nonempty search hits in the executable's ranking order."""
+
+    hits: tuple[MemorySearchResult, ...]
+
+
+@dataclass(frozen=True)
+class Empty:
+    """A valid successful search returned no hits."""
+
+
+type CheckCovenantVerdict = Upheld | Blocked | Unjudged
+type MemoryIngestOutcome = Ingested | Unavailable
+type MemorySearchOutcome = Found | Empty | Unavailable

polydeukes_sdk-0.19.1/src/polydeukes_sdk/_process.py

@@ -0,0 +1,70 @@
+"""Executable resolution and binary process transport shared by all verbs."""
+
+import math
+import os
+import subprocess
+
+from ._contract import Path, Spawn, SpawnOutcome, SpawnSpec
+
+
+def _absolute(path: Path, cwd: str) -> str:
+    return os.path.normpath(os.path.join(cwd, os.fspath(path)))
+
+
+def _resolve(executable: Path | None, cwd: str) -> str:
+    if executable is not None:
+        return _absolute(executable, cwd)
+    for directory in os.environ.get("PATH", "").split(os.pathsep):
+        if os.path.isabs(directory):
+            candidate = os.path.join(directory, "pdks")
+            if os.path.isfile(candidate) and os.access(candidate, os.X_OK):
+                return candidate
+    raise FileNotFoundError("No executable pdks found in absolute PATH directories")
+
+
+def _spawn(spec: SpawnSpec) -> SpawnOutcome:
+    child = subprocess.Popen(
+        (spec.command, *spec.args),
+        cwd=spec.cwd,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        close_fds=True,
+    )
+    try:
+        stdout, stderr = child.communicate(spec.stdin, timeout=spec.timeout)
+    except BaseException:
+        child.kill()
+        child.wait()
+        # A surviving descendant can keep these pipes open after the direct child exits.
+        for stream in (child.stdin, child.stdout, child.stderr):
+            if stream is not None:
+                stream.close()
+        raise
+    return SpawnOutcome(
+        status=child.returncode if child.returncode >= 0 else None,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+
+def run(
+    root: Path,
+    executable: Path | None,
+    timeout: float | None,
+    spawn: Spawn | None,
+    args: tuple[str, ...],
+    stdin: bytes,
+) -> SpawnOutcome:
+    if timeout is not None and (not math.isfinite(timeout) or timeout < 0):
+        raise ValueError("timeout must be finite and nonnegative")
+    cwd = os.getcwd()
+    return (spawn or _spawn)(
+        SpawnSpec(
+            command=_resolve(executable, cwd),
+            args=args,
+            cwd=_absolute(root, cwd),
+            stdin=stdin,
+            timeout=timeout,
+        )
+    )

polydeukes_sdk-0.19.1/src/polydeukes_sdk/ir.py

@@ -0,0 +1,83 @@
+# generated by datamodel-codegen:
+#   filename:  covenant-input.schema.json
+
+from __future__ import annotations
+
+from typing import Any, Literal, NotRequired, TypedDict
+
+
+class FileChangeCreate(TypedDict):
+    kind: Literal['create']
+    path: str
+    post: str
+
+
+class FileChangeModify(TypedDict):
+    kind: Literal['modify']
+    path: str
+    pre: str
+    post: str
+
+
+class FileChangeDelete(TypedDict):
+    kind: Literal['delete']
+    path: str
+    pre: NotRequired[str]
+
+
+type FileChange = FileChangeCreate | FileChangeModify | FileChangeDelete
+
+
+class SubagentSpawn(TypedDict):
+    kind: str
+
+
+class UserMessage(TypedDict):
+    text: str
+
+
+class Channels(TypedDict):
+    sidecar: NotRequired[str]
+
+
+class Actor(TypedDict):
+    agentType: NotRequired[str]
+
+
+class Tools(TypedDict):
+    mutating: list[str]
+    shell: list[str]
+    commandArgs: list[str]
+
+
+class SessionUserMessage(TypedDict):
+    text: str
+    timestampMs: NotRequired[float]
+
+
+class SessionToolCall(TypedDict):
+    name: str
+    args: NotRequired[dict[str, Any]]
+    succeeded: NotRequired[bool]
+
+
+class ToolCall(TypedDict):
+    name: str
+    args: NotRequired[dict[str, Any]]
+    fileChange: NotRequired[FileChange]
+
+
+class Session(TypedDict):
+    evidencePath: NotRequired[str]
+    userMessages: list[SessionUserMessage]
+    toolCalls: list[SessionToolCall]
+    channels: NotRequired[Channels]
+
+
+class CovenantInput(TypedDict):
+    toolCalls: list[ToolCall]
+    subagentSpawns: list[SubagentSpawn]
+    userMessages: list[UserMessage]
+    actor: NotRequired[Actor]
+    tools: NotRequired[Tools]
+    session: NotRequired[Session]

polydeukes_sdk-0.19.1/src/polydeukes_sdk/memory.py

@@ -0,0 +1,23 @@
+# generated by datamodel-codegen:
+#   filename:  memory-search-output.schema.json
+
+from __future__ import annotations
+
+from typing import Literal, TypedDict
+
+
+class MemorySearchResult(TypedDict):
+    id: str
+    conceptId: str
+    docTitle: str
+    sectionTitle: str
+    status: str
+    trust: Literal['human-reviewed', 'machine-verified', 'unverified']
+    stale: bool
+    matchPath: Literal['and', 'or', 'like']
+    supersededBy: list[str]
+
+
+class MemorySearchOutput(TypedDict):
+    ingestedAt: str
+    results: list[MemorySearchResult]