stepstitch-service 0.5.0__tar.gz

stepstitch_service-0.5.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: stepstitch-service
+Version: 0.5.0
+Summary: StepStitch backend service: deterministic Playwright compiler + decoupled router factory + MCP connector.
+License: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.104
+Requires-Dist: pydantic>=2.5
+Provides-Extra: test
+Requires-Dist: httpx>=0.27; extra == "test"
+Requires-Dist: pytest>=8.0; extra == "test"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == "mcp"
+Requires-Dist: httpx>=0.27; extra == "mcp"
+Provides-Extra: delivery
+Requires-Dist: httpx>=0.27; extra == "delivery"
+Provides-Extra: github
+Requires-Dist: httpx>=0.27; extra == "github"
+Provides-Extra: lint
+Requires-Dist: import-linter>=2.0; extra == "lint"
+Requires-Dist: ruff>=0.6; extra == "lint"
+Requires-Dist: mypy>=1.8; extra == "lint"

stepstitch_service-0.5.0/pyproject.toml

@@ -0,0 +1,101 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stepstitch-service"
+version = "0.5.0"  # x-release-please-version
+description = "StepStitch backend service: deterministic Playwright compiler + decoupled router factory + MCP connector."
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+dependencies = [
+    "fastapi>=0.104",
+    "pydantic>=2.5",
+]
+
+[project.optional-dependencies]
+test = ["httpx>=0.27", "pytest>=8.0"]
+# The universal agentic connector (docs/PRODUCT-PLAN.md P1). Optional so the core
+# service stays dependency-free; the MCP tool registry + dispatch are pure Python and
+# need no extra — only `serve_stdio` (the stdio transport) requires this.
+mcp = ["mcp>=1.0", "httpx>=0.27"]
+# Reference HTTP clients for the optional governed direct-write (delivery/clients.py).
+delivery = ["httpx>=0.27"]
+# Reference GitHub client for the optional Repair Loop bridge (github_bridge/client.py).
+github = ["httpx>=0.27"]
+# Architecture/layering boundary enforcement (docs/PRODUCT-PLAN.md P3). The boundary is also
+# proven dependency-free by tests/test_open_core_boundary.py; this is for CI `lint-imports`.
+# ruff/mypy are pinned-floor here so CI installs blocking-gate versions (no ad-hoc installs).
+lint = ["import-linter>=2.0", "ruff>=0.6", "mypy>=1.8"]
+
+[tool.setuptools]
+# All Apache-2.0. The concrete adapters (integrations.bundle + servicenow/salesforce/genesys)
+# are injected by the host; the core never imports them (a layering rule, not a license one).
+# See COMMERCIAL.md and tests/test_open_core_boundary.py.
+packages = [
+    "stepstitch_service",
+    "stepstitch_service.integrations",
+    "stepstitch_service.integrations.contrib",
+    "stepstitch_service.delivery",
+    "stepstitch_service.github_bridge",
+    "stepstitch_service.verification",
+]
+
+# Layering boundary: no core module may import a concrete adapter (keeps the privacy seam
+# clean and the adapter set swappable — independent of licensing).
+[tool.importlinter]
+root_package = "stepstitch_service"
+
+[[tool.importlinter.contracts]]
+name = "Core must not import concrete adapters"
+type = "forbidden"
+source_modules = [
+    "stepstitch_service.router",
+    "stepstitch_service.scrubber",
+    "stepstitch_service.compiler",
+    "stepstitch_service.replayability",
+    "stepstitch_service.retention",
+    "stepstitch_service.profiles",
+    "stepstitch_service.compliance",
+    "stepstitch_service.mcp_server",
+    "stepstitch_service.mcp_cli",
+    "stepstitch_service.integrations.base",
+    "stepstitch_service.delivery.base",
+    "stepstitch_service.delivery.servicenow_writer",
+    "stepstitch_service.delivery.salesforce_writer",
+    "stepstitch_service.delivery.config",
+    "stepstitch_service.delivery.clients",
+    "stepstitch_service.github_bridge.content",
+    "stepstitch_service.github_bridge.client",
+    "stepstitch_service.github_bridge.bridge",
+    "stepstitch_service.github_bridge.workflow",
+    "stepstitch_service.verification.verdict",
+]
+forbidden_modules = [
+    "stepstitch_service.integrations.servicenow",
+    "stepstitch_service.integrations.salesforce",
+    "stepstitch_service.integrations.genesys",
+    "stepstitch_service.integrations.bundle",
+]
+
+# Lint gate (blocking in CI). Intentionally small + stable rule set: pycodestyle errors (E),
+# pyflakes (F), and isort import ordering (I). Not a style crusade — just correctness + order.
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+
+[tool.ruff.lint.per-file-ignores]
+# workflow.py is a single raw-string literal: the verbatim GitHub Actions YAML we emit into
+# customers' repos. Its long lines (curl/python one-liners) cannot be reflowed without changing
+# the generated workflow, so E501 is intentionally not enforced on this template file.
+"stepstitch_service/github_bridge/workflow.py" = ["E501"]
+
+# Type gate (blocking in CI), scoped to the service package only. Non-strict baseline:
+# we do NOT enable disallow_untyped_defs etc. — the goal is a real, green floor we can ratchet up.
+[tool.mypy]
+python_version = "3.10"
+ignore_missing_imports = true
+warn_unused_ignores = false

stepstitch_service-0.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stepstitch_service-0.5.0/stepstitch_service/__init__.py

@@ -0,0 +1,48 @@
+"""StepStitch backend service package (host-agnostic)."""
+from .compiler import generate_playwright_test
+from .compliance import build_evidence
+from .mcp_server import (
+    COPILOT_SAFE_OPERATIONS,
+    assert_no_destructive_operation,
+    build_function_tool_specs,
+    build_tool_definitions,
+    dispatch_tool,
+    serve_stdio,
+)
+from .profiles import (
+    DEFAULT_PROFILE,
+    available_profiles,
+    load_profile,
+    policy_from_profile,
+)
+from .replayability import score_trace
+from .retention import purge_expired_traces
+from .router import create_stepstitch_router
+from .scrubber import (
+    FINANCIAL_SERVICES_ENTERPRISE,
+    ScrubPolicy,
+    ScrubRejection,
+    scrub_trace_payload,
+)
+
+__all__ = [
+    "generate_playwright_test",
+    "score_trace",
+    "create_stepstitch_router",
+    "purge_expired_traces",
+    "scrub_trace_payload",
+    "ScrubPolicy",
+    "ScrubRejection",
+    "FINANCIAL_SERVICES_ENTERPRISE",
+    "load_profile",
+    "policy_from_profile",
+    "available_profiles",
+    "DEFAULT_PROFILE",
+    "build_evidence",
+    "COPILOT_SAFE_OPERATIONS",
+    "assert_no_destructive_operation",
+    "build_tool_definitions",
+    "build_function_tool_specs",
+    "dispatch_tool",
+    "serve_stdio",
+]

stepstitch_service-0.5.0/stepstitch_service/compiler.py

@@ -0,0 +1,226 @@
+"""Deterministic StepStitch -> Playwright compiler.
+
+Pure functions, no I/O, no network, no embedded credentials. Given a trace's
+structural footsteps (see contracts/stepstitch.md), emit an executable Playwright
+TypeScript reproduction script. Output is fully determined by the inputs so it is
+trivially unit-testable.
+
+The compiled test is a real regression test: a captured API failure becomes an
+armed ``page.waitForResponse`` (matched on URL + method, so it resolves whether or
+not the bug is present) plus a status assertion, and a captured client exception
+becomes a ``pageerror`` assertion. The test therefore FAILS while the bug is
+present and PASSES once it is fixed (red -> green).
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .replayability import score_trace
+
+__all__ = ["generate_playwright_test"]
+
+
+def _ts_str(value: str) -> str:
+    """Escape a string for a single-quoted TS literal."""
+    return value.replace("\\", "\\\\").replace("'", "\\'")
+
+
+def _comment(text: str) -> str:
+    """Sanitize text for a single-line TS comment (no newlines/CR)."""
+    return text.replace("\r", " ").replace("\n", " ")
+
+
+def _coerce_status(value: Any) -> Optional[int]:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _url_prefix(endpoint: str) -> str:
+    """Literal URL prefix before the first templated segment.
+
+    ``/api/accounts/:id/transfers`` -> ``/api/accounts/`` so ``url().includes(...)``
+    matches the concrete runtime URL (``/api/accounts/123/transfers``).
+    """
+    if not endpoint:
+        return ""
+    marker = endpoint.find("/:")
+    if marker != -1:
+        return endpoint[: marker + 1]
+    colon = endpoint.find(":")
+    if colon != -1:
+        return endpoint[:colon]
+    return endpoint
+
+
+def _status_assertion(var: str, status: Optional[int], endpoint: str) -> str:
+    ep = _comment(endpoint or "the endpoint")
+    if status is not None and status >= 500:
+        return f"  expect({var}.status(), 'no server error from {ep}').toBeLessThan(500);"
+    if status is not None:
+        return f"  expect({var}.status(), '{ep} must not return {status}').not.toBe({status});"
+    return f"  expect({var}.status(), '{ep} must succeed').toBeLessThan(400);"
+
+
+def _arm_wait(var: str, prefix: str, method: str) -> List[str]:
+    method_clause = (
+        f" && r.request().method() === '{_ts_str(method.upper())}'" if method else ""
+    )
+    return [
+        f"  const {var} = page.waitForResponse(",
+        f"    (r) => r.url().includes('{_ts_str(prefix)}'){method_clause},",
+        "  );",
+    ]
+
+
+def generate_playwright_test(
+    trace_id: str,
+    footsteps: List[Dict[str, Any]],
+    base_url: str = "http://localhost:3000",
+) -> str:
+    """Compile footsteps into Playwright TS.
+
+    `base_url` is caller-supplied (no hardcoded host). Routes are templates
+    (e.g. ``/accounts/:id``); where a template contains ``:`` a TODO is emitted so the
+    engineer substitutes a concrete id. No credentials are ever embedded — auth is left
+    as a TODO for the operator to wire to a synthetic/test account.
+    """
+    base = base_url.rstrip("/")
+    replay = score_trace(footsteps)
+    has_exception = any(
+        str(s.get("type", "")).lower() == "exception" for s in footsteps
+    )
+
+    lines: List[str] = [
+        "import { test, expect } from '@playwright/test';",
+        "",
+        f"// StepStitch autogenerated reproduction (trace: {_comment(trace_id)})",
+        f"// Replayability: {replay['score']:.2f} (grade {replay['grade']})",
+    ]
+    for w in replay["warnings"]:
+        where = f" [step {w['step_index']}]" if "step_index" in w else ""
+        lines.append(f"//   ⚠ {w['code']}{where}: {_comment(w['detail'])}")
+    lines += [
+        "// NOTE: no credentials are embedded. Wire authentication to a synthetic",
+        "// test account before running against a protected route.",
+        "test('StepStitch reproduction', async ({ page }) => {",
+        "  // TODO: authenticate as a synthetic test user if the flow requires it.",
+        "",
+    ]
+    if has_exception:
+        lines += [
+            "  // Capture uncaught client exceptions so we can assert they no longer occur.",
+            "  const pageErrors: string[] = [];",
+            "  page.on('pageerror', (e) => pageErrors.push(e.message));",
+            "",
+        ]
+
+    asserted = False
+    resp_n = 0
+
+    def emit_action(step_type: str, route: str, target: Optional[str], label: str) -> None:
+        if step_type == "navigation":
+            if ":" in route:
+                lines.append(
+                    f"  // TODO: substitute id(s) in templated route '{_comment(route)}'"
+                )
+            lines.append(f"  await page.goto('{_ts_str(base + route)}');")
+        elif step_type == "click" and target:
+            if label and label != "[masked]":
+                lines.append(f"  // label: {_comment(label)}")
+            lines.append(f"  await page.locator('{_ts_str(target)}').click();")
+        elif step_type == "input" and target:
+            lines.append("  // value redacted by StepStitch; fill a test value:")
+            lines.append(
+                f"  await page.locator('{_ts_str(target)}').fill('stepstitch-test-value');"
+            )
+
+    i = 0
+    n = len(footsteps)
+    while i < n:
+        step = footsteps[i]
+        step_type = str(step.get("type", "")).lower()
+        route = str(step.get("route", "/"))
+        target = step.get("target")
+        label = str(step.get("label", ""))
+        metadata = step.get("metadata") or {}
+
+        nxt = footsteps[i + 1] if i + 1 < n else None
+        nxt_is_api = nxt is not None and str(nxt.get("type", "")).lower() == "api_error"
+
+        lines.append(f"  // [{step_type.upper()}] {_comment(route)}")
+
+        # An interaction immediately followed by an API error: arm the response
+        # wait BEFORE the action, then assert on the response after it.
+        if step_type in ("navigation", "click", "input") and nxt_is_api and nxt is not None:
+            api_meta = nxt.get("metadata") or {}
+            endpoint = str(api_meta.get("endpoint", ""))
+            status = _coerce_status(api_meta.get("status"))
+            method = str(api_meta.get("method", ""))
+            var = f"response{resp_n}"
+            lines += _arm_wait(var, _url_prefix(endpoint), method)
+            emit_action(step_type, route, target, label)
+            lines.append(
+                f"  // expected API failure: {_comment(endpoint)} "
+                f"(HTTP {api_meta.get('status', '?')})"
+            )
+            lines.append(f"  const res{resp_n} = await {var};")
+            lines.append(_status_assertion(f"res{resp_n}", status, endpoint))
+            asserted = True
+            resp_n += 1
+            lines.append("")
+            i += 2
+            continue
+
+        if step_type in ("navigation", "click", "input"):
+            emit_action(step_type, route, target, label)
+
+        elif step_type == "api_error":
+            # Standalone API error (no immediately preceding interaction): bind a
+            # short post-hoc wait so we still assert rather than just comment.
+            endpoint = str(metadata.get("endpoint", ""))
+            status = _coerce_status(metadata.get("status"))
+            method = str(metadata.get("method", ""))
+            method_clause = (
+                f" && r.request().method() === '{_ts_str(method.upper())}'"
+                if method
+                else ""
+            )
+            lines.append(
+                f"  // expected API failure: {_comment(endpoint)} "
+                f"(HTTP {metadata.get('status', '?')})"
+            )
+            lines.append(
+                f"  const res{resp_n} = await page.waitForResponse("
+            )
+            lines.append(
+                f"    (r) => r.url().includes('{_ts_str(_url_prefix(endpoint))}'){method_clause},"
+            )
+            lines.append("  );")
+            lines.append(_status_assertion(f"res{resp_n}", status, endpoint))
+            asserted = True
+            resp_n += 1
+
+        elif step_type == "exception":
+            name = str(metadata.get("error_type") or metadata.get("name") or "Error")
+            lines.append(
+                f"  expect(pageErrors.some((m) => m.includes('{_ts_str(_comment(name))}')), "
+                f"'the reported {_comment(name)} must not reproduce').toBe(false);"
+            )
+            asserted = True
+
+        lines.append("")
+        i += 1
+
+    if not asserted:
+        lines.append(
+            "  // Navigation-only trace: no terminal failure was captured to assert on."
+        )
+        lines.append(
+            "  // See the replayability warnings above; add a fixture/assertion to make this a"
+        )
+        lines.append("  // true regression test.")
+
+    lines.append("});")
+    return "\n".join(lines) + "\n"

stepstitch_service-0.5.0/stepstitch_service/compliance.py

@@ -0,0 +1,231 @@
+"""Compliance evidence — generated from the live ScrubPolicy, never hand-maintained.
+
+A security reviewer's first question is "what do you capture, and what do you never
+capture?". This module answers it from *code*: the capture/never-capture matrix is
+derived directly from the active :class:`ScrubPolicy` (allowlists + forbidden keys), so
+the evidence packet cannot drift from what the scrubber actually enforces. The drift
+guard in ``service/tests/test_compliance.py`` fails CI if the committed
+``COMPLIANCE-EVIDENCE.md`` stops matching the policy.
+
+Output is deterministic (no timestamps) precisely so it can be drift-guarded.
+"""
+from __future__ import annotations
+
+from typing import List
+
+from .profiles import PROFILES
+from .scrubber import FINANCIAL_SERVICES_ENTERPRISE, ScrubPolicy
+
+__all__ = ["build_evidence", "NEVER_CAPTURED_CATEGORIES", "ALWAYS_STRUCTURAL"]
+
+# Human-facing categories the product never records (independent of key names).
+NEVER_CAPTURED_CATEGORIES = (
+    "Screenshots / video",
+    "Input values (what a user typed)",
+    "Page text / DOM content",
+    "Raw URLs (templated to routes)",
+    "Request / response bodies",
+    "Raw frontend logs / console messages / stack traces",
+    "Network headers / cookies",
+    "SSNs, account/card numbers, emails, phone numbers (redacted from free text)",
+)
+
+ALWAYS_STRUCTURAL = (
+    "Route templates (e.g. /accounts/:id)",
+    "Stable selectors (data-testid preferred)",
+    "API status codes",
+    "Endpoint templates and source-path templates",
+    "Exception types",
+    "SDK/build/release metadata",
+    "Masked labels",
+)
+
+# --- Regulatory crosswalk (code-derived; cites the frameworks a reviewer applies) ----
+_REGSP = "SEC Reg S-P (2024)"
+_MRM = "2026 interagency MRM (supersedes SR 11-7)"
+_HIPAA = "HIPAA"
+_NIST = "NIST AI RMF"
+
+# Each control maps to a citation per framework ("—" = not the controlling regime).
+_CROSSWALK = (
+    ("Server-side scrub / NPI data-minimization (`scrubber.py`)", {
+        _REGSP: "Safeguards Rule — protect customer NPI",
+        _MRM: "Sound, controlled data inputs",
+        _HIPAA: "Minimum-necessary; no PHI stored",
+        _NIST: "MAP/MEASURE — data governance",
+    }),
+    ("Split retention + 5-yr audit clock (`retention.py`)", {
+        _REGSP: "Recordkeeping — incident records retained 5 yrs",
+        _MRM: "Auditability & traceability of model use",
+        _HIPAA: "Retain access/audit records",
+        _NIST: "GOVERN — documentation & records",
+    }),
+    ("Admin-only reads, audit on every read (`router.py`)", {
+        _REGSP: "Access controls; incident-response program",
+        _MRM: "Traceability / effective challenge",
+        _HIPAA: "Access controls & audit logging",
+        _NIST: "GOVERN/MANAGE — accountability",
+    }),
+    ("Org-wide kill switch, fail-safe (`router.py`)", {
+        _REGSP: "Incident-response containment",
+        _MRM: "Controls & human override",
+        _HIPAA: "Contingency / incident response",
+        _NIST: "MANAGE — incident response",
+    }),
+    ("Deterministic compiler + replayability + eval gate "
+     "(`compiler.py`, `test_repro_eval.py`)", {
+        _REGSP: "—",
+        _MRM: "Ongoing monitoring & output quality",
+        _HIPAA: "—",
+        _NIST: "MEASURE — validity & reliability",
+    }),
+    ("Draft-only, human-in-the-loop (`integrations/`, `copilot/action-policy.md`)", {
+        _REGSP: "—",
+        _MRM: "Human oversight — outputs support, not replace, decisions",
+        _HIPAA: "—",
+        _NIST: "GOVERN — human-AI configuration",
+    }),
+)
+
+# Release gates reframed as model-risk validation / ongoing-monitoring evidence.
+_MRM_GATES = (
+    ("End-to-end golden path", "`test_golden_path.py`", "System validation"),
+    ("Server-side scrub boundary", "`test_scrubber.py`", "Data-control validation"),
+    ("Profile drift guard", "`test_profiles.py`", "Configuration control"),
+    ("Executable repro proof", "`scripts/prove-repro-executes.mjs`", "Output validity"),
+    ("Reproduction quality eval", "`test_repro_eval.py`", "Ongoing output-quality monitoring"),
+    ("Open-core import boundary", "`.importlinter` / `test_open_core_boundary.py`",
+     "Change control / segregation of duties"),
+    ("Compliance evidence drift guard", "`test_compliance.py`", "Documentation currency"),
+)
+
+
+def _bullets(items) -> List[str]:
+    return [f"- {i}" for i in items]
+
+
+def _frameworks_for(policy: ScrubPolicy) -> List[str]:
+    """The framework columns that apply to a profile."""
+    if policy.name == "healthcare-strict":
+        return [_HIPAA, _NIST]
+    return [_REGSP, _MRM, _NIST]
+
+
+def _crosswalk_section(policy: ScrubPolicy) -> List[str]:
+    cols = _frameworks_for(policy)
+    lines = [
+        "## Regulatory crosswalk",
+        "",
+        "The controls above mapped to the frameworks a regulated reviewer applies "
+        f"(columns selected for the `{policy.name}` profile).",
+        "",
+        "| Control | " + " | ".join(cols) + " |",
+        "|---|" + "|".join("---" for _ in cols) + "|",
+    ]
+    for control, mapping in _CROSSWALK:
+        cells = " | ".join(mapping.get(c, "—") for c in cols)
+        lines.append(f"| {control} | {cells} |")
+    lines.append("")
+    return lines
+
+
+def _mrm_section() -> List[str]:
+    lines = [
+        "## Model risk management evidence",
+        "",
+        "Under the **April-2026 interagency model risk management guidance (superseding "
+        "SR 11-7)**, StepStitch's release gates are the validation & ongoing-monitoring "
+        "evidence — each a named, runnable check:",
+        "",
+        "| Gate | Check | MRM role |",
+        "|---|---|---|",
+    ]
+    for gate, check, role in _MRM_GATES:
+        lines.append(f"| {gate} | {check} | {role} |")
+    lines += [
+        "",
+        "StepStitch is a deterministic, **draft-only provider**: it produces evidence and "
+        "drafts for human decision-makers and never takes autonomous action, keeping AI "
+        "outputs in a \"support, not replace\" posture for fiduciary use.",
+        "",
+    ]
+    return lines
+
+
+def build_evidence(policy: ScrubPolicy = FINANCIAL_SERVICES_ENTERPRISE) -> str:
+    """Return the compliance evidence packet (Markdown) for ``policy``."""
+    forbidden = sorted(policy.forbidden_keys)
+    meta_allow = sorted(policy.metadata_allowlist)
+    fs_meta_allow = sorted(policy.footstep_metadata_allowlist)
+
+    lines: List[str] = [
+        "# StepStitch — Compliance Evidence",
+        "",
+        "> Generated from the live `ScrubPolicy` by "
+        "`scripts/generate_compliance_evidence.py`. Do not edit by hand — the drift "
+        "guard in `service/tests/test_compliance.py` keeps this file equal to the code.",
+        "",
+        f"**Active policy:** `{policy.name}`  ",
+        f"**Free-text handling:** `{policy.free_text}` (max {policy.max_text_len} chars)  ",
+        f"**Forbidden key on payload →** "
+        f"{'reject (HTTP 422)' if policy.reject_on_forbidden else 'dropped + reported'}",
+        "",
+        "## What StepStitch never captures",
+        "",
+        *_bullets(NEVER_CAPTURED_CATEGORIES),
+        "",
+        "## What StepStitch captures (structural only)",
+        "",
+        *_bullets(ALWAYS_STRUCTURAL),
+        "",
+        "## Server-side enforcement (defense-in-depth)",
+        "",
+        "Every ingestion is scrubbed server-side before storage, independent of the SDK "
+        "(`service/stepstitch_service/scrubber.py`). The browser SDK also redacts, but "
+        "the server never trusts the client.",
+        "",
+        "### Metadata allowlist (everything else dropped)",
+        "",
+        f"- Top-level: {', '.join(f'`{k}`' for k in meta_allow)}",
+        f"- Footstep: {', '.join(f'`{k}`' for k in fs_meta_allow)}",
+        "",
+        "### Forbidden keys (dropped as a leak signal)",
+        "",
+        *_bullets(f"`{k}`" for k in forbidden),
+        "",
+        "## Operational controls",
+        "",
+        "- Consent required before capture; GPC and DNT respected (capture stays off).",
+        "- Admin-only operator reads; **every** read writes an audit event.",
+        "- Right-to-delete removes trace bodies; the deletion audit record is retained.",
+        "- Split retention: bodies purged on a short clock; audit records on a separate "
+        "5-year clock (SEC Reg S-P 2024).",
+        "- Org-wide kill switch refuses ingestion (HTTP 503) with no row written; a "
+        "broken flag fails safe (capture OFF).",
+        "- Per-trace scrub report stored at `trace_metadata._scrub` and returned on "
+        "ingestion.",
+        "",
+        "## Deployment profiles",
+        "",
+        "| Profile | free_text | forbidden-key handling |",
+        "|---|---|---|",
+    ]
+    for name in sorted(PROFILES):
+        scrub = PROFILES[name]["scrub"]
+        handling = "reject (422)" if scrub.get("reject_on_forbidden") else "drop"
+        lines.append(f"| `{name}` | {scrub.get('free_text')} | {handling} |")
+
+    lines.append("")
+    lines += _crosswalk_section(policy)
+    lines += _mrm_section()
+
+    lines += [
+        "## Verification",
+        "",
+        "- `pytest service/tests` — scrubber, replayability, profiles, integrations, "
+        "Copilot surface, retention, compiler, router.",
+        "- `ruff check service` — lint.",
+        "- `sbom.cdx.json` — supply-chain bill of materials.",
+        "",
+    ]
+    return "\n".join(lines) + "\n"

stepstitch_service-0.5.0/stepstitch_service/delivery/__init__.py

@@ -0,0 +1,43 @@
+"""StepStitch optional governed direct-write (off by default).
+
+Delivers the already-sanitized export-preview draft to a system of record. Off unless a host
+injects configured writers; human-approval-gated; audited; and never on the agent surface.
+See ``base.py`` for the trust model.
+"""
+from .base import (
+    DeliveryError,
+    DeliveryResult,
+    DeliveryService,
+    HttpPostFn,
+    RecordWriter,
+)
+from .config import enabled_targets_from_env
+from .salesforce_writer import SalesforceWriter
+from .servicenow_writer import ServiceNowWriter
+
+# Reference HTTP clients require the optional [delivery] extra (httpx); import lazily so the
+# core stays dependency-free.
+try:  # pragma: no cover - exercised via the [delivery] extra
+    from .clients import (
+        http_post_client,
+        salesforce_bearer,
+        servicenow_basic,
+        servicenow_bearer,
+    )
+except Exception:  # noqa: BLE001 - clients are optional
+    http_post_client = salesforce_bearer = servicenow_basic = servicenow_bearer = None  # type: ignore
+
+__all__ = [
+    "RecordWriter",
+    "DeliveryResult",
+    "DeliveryError",
+    "DeliveryService",
+    "HttpPostFn",
+    "ServiceNowWriter",
+    "SalesforceWriter",
+    "enabled_targets_from_env",
+    "http_post_client",
+    "servicenow_basic",
+    "servicenow_bearer",
+    "salesforce_bearer",
+]